[OLY] Golem Invocation Remake

scope GolemInvocation initializer Init
//===========================================================================
//=============================SETUP START===================================
//===========================================================================

    globals
        private constant integer AID = 'A001'   //the rawcode of the ability
        private constant string ANIMATION = "birth" //the animation that will be played when the unit is created
        private constant integer MAX_GOLEM_TYPES = 3
        private integer array GOLEM_TYPES
        private real array GOLEM_CHANCES
    endglobals

    
//===========================================================================
//============================GOLEM SETUP====================================
//===========================================================================

    private function SetupGolemTypes takes integer level returns nothing
        set GOLEM_TYPES[0] = 'ngrk'
        set GOLEM_TYPES[1] = 'ngst'
        set GOLEM_TYPES[2] = 'nggr'
    endfunction
    
    private function GolemChances takes integer level returns nothing
        set GOLEM_CHANCES[0] = 1. - (level * 0.1)
        set GOLEM_CHANCES[1] = (level * 0.07) - 0.01
        set GOLEM_CHANCES[2] = 0.01 + (0.03 * level)
    endfunction


    private constant function golemLife takes integer level returns real
        return level * 20.  //the amount of time each golem will be alive live
    endfunction

    private constant function channelGolems takes integer level returns boolean
        //if true it will make all spawned golems die when the caster stops the channel
        //if false, it allows the golems to have golemLife seconds of life and they
        //will not die when the caster stops the channel
        //in this case my golems 20, 40 and 60 seconds of life for each leavel.
        return false
        
        //example of usage

//        if (level == 3) then
//            return false
//        endif
//        return true

        //in this example the golems will die when the channel ends in level 1 and 2
        //in level 3, the golems will live 60 seconds of life
    endfunction
    
    private constant function golemsPerCycle takes integer level returns integer
        //the number of golems that will be created each cycle
        return 1 + (level * 0)
    endfunction
    
    
    private constant function cycle takes integer level returns real
        //the cycle which will determine when we create golems
        //this means, golemsPerCycle golems are created every cycle
        //in this case, we create 1 golem per second (in this case a second 
        //is a cycle)
        return 1. + (level * 0) 
    endfunction
    
//===========================================================================
//============================DUST SETUP=====================================
//===========================================================================
    
    private constant function dummyEffectId takes integer level returns integer
        //the rawcode of the dummy unit that will be dust
        //this is in a function so you can have different effects in different
        //levels
        return 'h000'
    endfunction
    
    private constant function minRange takes integer level returns real
        //in this case we dont have a minimum range, which means we can 
        //create units at the center of the circle
        //the minimum range is smaller circle, inside the area of the spell
        //in which golems will not be created
        return 0.
    endfunction
    
    private constant function maxRange takes integer level returns real
        //this ensures golems are not created outside the AOE of the spell
        //this gives the AOE of the spell
        return 200. + (level * 100)
    endfunction
    
    private constant function circleCount takes integer level returns integer
        //the number of circles that will be created to give the illusion of the dust
        //effect. The more circles the more realistic, but more CPU will be needed.
        return 3 + level 
    endfunction
    
    private constant function innerCircleUnits takes integer level returns integer
        //the number of units that the most inner circle will have
        return level + 5
    endfunction
    
    private constant function innerCircleUnitsIncrease takes integer level returns integer
        //the increment of units per circle
        return level + 2
    endfunction
//===========================================================================
//=============================SETUP END=====================================
//===========================================================================

    globals 
        private group GolemInvocationCasters
        private HandleTable activeTable 
    endglobals
    
    private struct MyStruct 
        unit caster
        integer level
        timer cycleTimer 
        real spellLocX
        real spellLocY
        group dummyEffects
        group golems
        
        static method create takes unit caster, real locX, real locY returns MyStruct
            local MyStruct data = MyStruct.allocate()
            
            //set variables about the caster
            set data.caster = caster
            set data.level = GetUnitAbilityLevel(data.caster, AID)
            
            //variables about the location
            set data.spellLocX = locX
            set data.spellLocY = locY
            
            //the timer which will determine when we create golems
            //creates a golem everytime it expires
            set data.cycleTimer = NewTimer()   
            
            //This groups will save the dumy dust effects, so we can kill them 
            //when the caster stops the channeling
            set data.dummyEffects = CreateGroup()
            
            //if we want the golems to die when the caster stops channel
            //then we create this group so we can add all golems to it
            //then we kill the golems when the caster stops the channel
            if (channelGolems(data.level)) then
                set data.golems = CreateGroup()
            endif
            
            return data
        endmethod
        
        method onDestroy takes nothing returns nothing
            
            //here we select all units from the group and we kill them all ! =P
            //thus meaning that the dust effects will disappear ! 
            local unit f
            loop
                set f = FirstOfGroup(.dummyEffects)
                exitwhen(f == null)
                call GroupRemoveUnit(.dummyEffects, f)
                call KillUnit(f)
            endloop
            
            //if the variable is true, then golems group was created and it has
            //units. Now we just kill all units it has and we release the group
            //for CSSafety to use one day later
            if (channelGolems(.level)) then
                loop
                    set f = FirstOfGroup(.golems)
                    exitwhen(f == null)
                    call GroupRemoveUnit(.golems, f)
                    call KillUnit(f)
            endloop
            
            call DestroyGroup(.golems)
            endif
            
            //since the spell is not active anymore, we clean the Table     
            call activeTable.flush(.caster) 
            
            //the units are not anymore in the active units group.
            call GroupRemoveUnit(GolemInvocationCasters, .caster) 
            
            //releasing the timer and group for CSSafety to use it one day later =D
            call ReleaseTimer(.cycleTimer)
            call DestroyGroup(.dummyEffects)
            
        endmethod
    endstruct
    
//===========================================================================
    private function onStop takes nothing returns boolean
        local MyStruct data
        local unit u = GetTriggerUnit()
        
        //when a unit stops the channel, we verify if that unit is inside the
        //catsers group. If so, than it is because it is a caster casting this spell
        //and so we recover information about him and we make the spell end
        if(IsUnitInGroup(u, GolemInvocationCasters)) then
            //recover the data from the caster
            set data = activeTable[u] 
            
            //now, time to clean the mess once again
            call data.destroy() 
        endif

        set u = null
        
        return false
    endfunction
//===========================================================================
    //Function made by Themerion and adapted by Flame_Phoenix
    //Creates circles of dummy units to give the illusion of the dust effect
    private function createDust takes integer aStruct returns nothing
        local MyStruct data = aStruct
        
        // forPlayer     -> Create the units for which player?
        local player forPlayer = GetOwningPlayer(data.caster)
        
        // innerRadius   -> The radius of the innermost circle
        // outerRadius   -> The radius of the outmost circle
        local real innerRadius = minRange(data.level)
        local real outerRadius = maxRange(data.level)
        
        // x and y       -> Center of circles
        local real x = data.spellLocX
        local real y = data.spellLocY

        local real radiusInc = (outerRadius - innerRadius) / I2R(circleCount(data.level)-1)
        
        //see functions they call
        local integer fxcount = innerCircleUnits(data.level)
        local integer fxcountinc = innerCircleUnitsIncrease(data.level)
        
        local real phi = 0
        local real phiInc

        loop
            exitwhen (innerRadius + 0.001 >= outerRadius)

            set phi = 0
            set phiInc = 2*bj_PI/I2R(fxcount)
            
            loop
                exitwhen (phi + 0.001 >= 2 * bj_PI)
                //we add the units to a group, so we can kill them when we want ! =P
                call GroupAddUnit(data.dummyEffects, CreateUnit(forPlayer, dummyEffectId(data.level), x + innerRadius * Cos(phi), y + innerRadius * Sin(phi), 180 + Rad2Deg(phi)))
                set phi = phi + phiInc
            endloop
            
            set innerRadius = innerRadius + radiusInc
            set fxcount = fxcount + fxcountinc
        
        endloop
        
        set forPlayer = null
    
    endfunction
//===========================================================================
    //Function made by Vexorian, it selects a random region in a disk. 
    //All regions have the same chance of beeing choosen
    private function GetRandomPointInDisk takes real centerx, real centery, real minradius, real maxradius returns location
        local real d = SquareRoot(GetRandomReal(minradius * minradius, maxradius * maxradius))
        local real a = GetRandomReal(0, 2 * bj_PI)
        return Location(centerx + d * Cos(a), centery + d * Sin(a))
    endfunction
//===========================================================================
    private function createGolems takes nothing returns nothing
        //we get the structure from the timer
        local MyStruct data = MyStruct(GetTimerData(GetExpiredTimer())) 
        
        //variables for us to know where the golems will born
        local location point  
        local real randomX  
        local real randomY 
        
        //the chances that each golem will have to be spawned
        local real aChance
        
        //just to keep count about how many golems we created
        local integer loopCounter = 0
        
        //variables about the golems
        local unit golem
        local real golemFacing = GetUnitFacing(data.caster)
        
        //Here we spawn the golems 
        loop 
            exitwhen(loopCounter >= golemsPerCycle(data.level))
                
            set point = GetRandomPointInDisk(data.spellLocX, data.spellLocY, minRange(data.level), maxRange(data.level))
            set randomX = GetLocationX(point)
            set randomY = GetLocationY(point)
            set aChance = GetRandomReal(0, 1)
            
            if (aChance <= 1 - GOLEM_CHANCES[0]) then
                set golem =  CreateUnit(GetOwningPlayer(data.caster), GOLEM_TYPES[0], randomX, randomY, golemFacing)
                call SetUnitAnimation( golem, ANIMATION )
                
                //if channelGolems(data.level) is true we add the golem to it 
                //so we can keep track of it and kill it later in the "onDestroy"
                //method
                //else if the variable is false, it means that the group was not
                //created, and we ant the units to have a LifeTime
                if (channelGolems(data.level)) then
                    call GroupAddUnit(data.golems, golem)
                else
                    call UnitApplyTimedLife(golem, 'BTLF', golemLife(data.level))
                endif
            elseif (aChance <= 1 - GOLEM_CHANCES[1]) then
                set golem =  CreateUnit(GetOwningPlayer(data.caster), GOLEM_TYPES[1], randomX, randomY, golemFacing)
                call SetUnitAnimation( golem, ANIMATION )
                
                //if channelGolems(data.level) is true we add the golem to it 
                //so we can keep track of it and kill it later in the "onDestroy"
                //method
                //else if the variable is false, it means that the group was not
                //created, and we ant the units to have a LifeTime
                if (channelGolems(data.level)) then
                    call GroupAddUnit(data.golems, golem)
                else
                    call UnitApplyTimedLife(golem, 'BTLF', golemLife(data.level))
                endif
            elseif (aChance <= 11 - GOLEM_CHANCES[2]) then
                set golem =  CreateUnit(GetOwningPlayer(data.caster), GOLEM_TYPES[2], randomX, randomY, golemFacing)
                call SetUnitAnimation( golem, ANIMATION )
                
                //if channelGolems(data.level) is true we add the golem to it 
                //so we can keep track of it and kill it later in the "onDestroy"
                //method
                //else if the variable is false, it means that the group was not
                //created, and we ant the units to have a LifeTime
                if (channelGolems(data.level)) then
                    call GroupAddUnit(data.golems, golem)
                else
                    call UnitApplyTimedLife(golem, 'BTLF', golemLife(data.level))
                endif
            endif   
            
            call RemoveLocation(point)
            set point = null
                
            set loopCounter = loopCounter + 1
        endloop
    
    set golem = null

    endfunction
//===========================================================================
    private function Conditions takes nothing returns boolean
        local MyStruct data
        local location spellLoc //the location of the spell
        
        if (GetSpellAbilityId() == AID) then
            //setting variables for the struct
            set spellLoc = GetSpellTargetLoc()
            set data = MyStruct.create(GetTriggerUnit(), GetLocationX(spellLoc), GetLocationY(spellLoc))
            
            //put the struct in the Table, we just use the caster's handle adress as 
            //the key which tells us where in the Table the struct is stored
            set activeTable[data.caster] = data 

            //  we add the casting unit to some sort of "pool"
            call GroupAddUnit(GolemInvocationCasters, data.caster)
            
            //now we create the dusty effect
            call createDust(data)
            
            //we attach the struct to the timer
            call SetTimerData(data.cycleTimer, integer(data))
            call TimerStart(data.cycleTimer, cycle(data.level), true, function createGolems)
            
            //cleaning up the mess
            call RemoveLocation(spellLoc)
        endif
        
        set spellLoc = null
        
        return false
    endfunction
//===========================================================================
    private function Init takes nothing returns nothing
        local trigger GolemInvocationTrigger = CreateTrigger(  )
        call TriggerRegisterAnyUnitEventBJ(GolemInvocationTrigger, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddCondition(GolemInvocationTrigger, Condition( function Conditions ) )
        
        set GolemInvocationTrigger = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ(GolemInvocationTrigger, EVENT_PLAYER_UNIT_SPELL_ENDCAST)
        call TriggerAddCondition(GolemInvocationTrigger,  Condition(function onStop))

        set GolemInvocationTrigger = null
        
        //set our globals
        set activeTable = HandleTable.create() 
        set GolemInvocationCasters = CreateGroup() 

        set GolemInvocationTrigger = null
    endfunction
endscope 

    private constant function golemsPerCycle takes integer level returns integer
        //the number of golems that will be created each cycle
        return 1 + (level * 0)
    endfunction

    private constant function cycle takes integer level returns real
        //the cycle which will determine when we create golems
        //this means, golemsPerCycle golems are created every cycle
        //in this case, we create 1 golem per second (in this case a second 
        //is a cycle)
        return 1. + (level * 0) 
    endfunction

private constant function GolemChances takes nothing returns Integer
    set GolemChances[MAX_GOLEM_TYPES*1+1] = 0.60 //It's a 2-D array, though I imagine it could be more efficient
    set GolemChances[MAX_GOLEM_TYPES*1+2] = 0.25 //The key here is "MAX_GOLEM_TYPES*<Level>+<Rank of Golem>"
    set GolemChances[MAX_GOLEM_TYPES*1+3] = 0.10 //Instead of all this manual setting, one could also use loops and that sort of stuff to set the array values properly, but I did it this way to easily show what I was doing
    set GolemChances[MAX_GOLEM_TYPES*1+4] = 0.05

    set GolemChances[MAX_GOLEM_TYPES*2+2] = 0.60 //The reason we're storing it in an array is to keep the user from having to figure out complex mathematic equations and/or having to set up branching if-then-else trees to return the proper chance
    set GolemChances[MAX_GOLEM_TYPES*2+3] = 0.25
    set GolemChances[MAX_GOLEM_TYPES*2+4] = 0.10
    set GolemChances[MAX_GOLEM_TYPES*2+5] = 0.05

    set GolemChances[MAX_GOLEM_TYPES*3+3] = 0.60
    set GolemChances[MAX_GOLEM_TYPES*3+4] = 0.25
    set GolemChances[MAX_GOLEM_TYPES*3+5] = 0.10
    set GolemChances[MAX_GOLEM_TYPES*3+6] = 0.05

   set GolemChances[0] = 0 //Also preventing crashes
endfunction

constant function UnitType takes integer Level returns integer
    if Level == 1 then
        return 'e005'
    elseif Level == 2 then
        return 'h0af'
    elseif Level == 3 then
        return 'e0g2'
    endif

    return 0
endfunction

//Somewhere in a function that uses this:
local integer Type = UnitType(Level)
local unit U = CreateUnit(GetTriggerPlayer(), Type, X, Y, 0.00)

globals
    private integer array UnitTypes
endglobals

//Assuming this function is called with an initializer
function UnitType takes nothing returns nothing
    set UnitTypes[0] = 0       //This should actually be included in the init function, but you could do it here too
    set UnitTypes[1] = 'e005'  //See how the array index corresponds with the proper level of the spell?
    set UnitTypes[2] = 'h0af'
    set UnitTypes[3] = 'e0g2'
endfunction

//Somewhere in a function that uses this
local unit U = CreateUnit(GetTriggerPlayer(), UnitTypes[Level], X, Y, 0.00)

constant function UnitType takes integer Level, integer Type returns integer
    if Level == 1 then
        if Type == 1 then
            return 'e005'
        elseif Type == 2 then
            return 'e006'
        endif
    elseif Level == 2 then
        if Type == 1 then
            return 'h0af'
        elseif Type == 2 then
            return 'h0gf'
        endif
    elseif Level == 3 then
        if Type == 1 then
            return 'e0g2'
        elseif Type == 2 then
            return 'e1f9'
        endif
    endif

    return 0
endfunction

//Somewhere in a function that uses this:
local integer Type1 = UnitType(Level, 1)
local integer Type2 = UnitType(Level, 2)
local unit U1 = CreateUnit(GetTriggerPlayer(), Type1, X, Y, 0.00)
local unit U2 = CreateUnit(GetTriggerPlayer(), Type2, X, Y, 0.00)

globals
    private integer array UnitTypes
    private constant integer MAX_TYPES = 2 //2 because the max number of types we want per level is 2
endglobals

//Assuming this function is called with an initializer
function UnitType takes nothing returns nothing
    set UnitTypes[0] = 0
    set UnitTypes[MAX_TYPES*1+1] = 'e005' //Okay, so a 2-D array would be like saying UnitTypes[1][1], with the second array index being a subset of the first
    set UnitTypes[MAX_TYPES*1+2] = 'e006 //However, we can't do this in JASS, so we have to be a bit tricky about our 2-D arrays
    set UnitTypes[MAX_TYPES*2+1] = 'h0af'
    set UnitTypes[MAX_TYPES*2+2] = 'h0gf' //So if you want to access MyArray[A][b], the formula we use is:
    set UnitTypes[MAX_TYPES*3+1] = 'e0g2' //MyArray[MAX_NUMBER_OF_Bs*A+B], thus resulting in the formula you see to the left
    set UnitTypes[MAX_TYPES*3+2] = 'e1f9'
endfunction

//Somewhere in a function that uses this
local unit U1 = CreateUnit(GetTriggerPlayer(), UnitTypes[MAX_TYPES*Level+1], X, Y, 0.00)
local unit U2 = CreateUnit(GetTriggerPlayer(), UnitTypes[MAX_TYPES*Level+2], X, Y, 0.00)

globals
    private unitpool array GolemPools
    private constant integer MAX_GOLEM_TYPES = 3
    private constant integer TOTAL_LEVELS
    private integer array GolemTypes
    private real array GolemChances
endglobals

private function Init takes nothing returns nothing
    local integer A = 0
    local integer B = 0

    call GolemTypes()
    call GolemChances()

    loop
        set A = A+1
        exitwhen A > TOTAL_LEVELS

        set GolemPools[A] = CreateUnitPool()
        set B = 0
        loop
            set B = B+1
            exitwen B>MAX_GOLEM_TYPES

            call UnitPoolAddUnitType(GolemPools[A], GolemTypes[MAX_GOLEM_TYPES*A+B], GolemChances[MAX_GOLEM_TYPES*A+B])
        endloop
    endloop
endfunction

//===========================================================================
//A spell that creates an Earthquake. This earthquake creates dust and spawns 
//golems inside the target area. Each golem has a period of life, and weaker
//golems have more chances to be spawned.
//
//Requires TimerUtils and Table
//
//@author Flame_Phoenix 
//
//@credits
//- the-thingy, Kyrbi0, Pyrogasm, Anitarf
//- My first teacher of vJASS: Blue_Jeans
//- All other people I forgot or ignored
//
//@version 1.3
//===========================================================================
scope GolemInvocation initializer Init

    //Gloabls for the spell's core, don't change
    globals 
        private integer array GOLEM_TYPES   
        private real array GOLEM_CHANCES
        private unitpool array GOLEM_POOLS
    endglobals
    
//===========================================================================
//=============================SETUP START===================================
//===========================================================================

    globals
        private constant integer AID = 'A001'   //the rawcode of the ability
        private constant string ANIMATION = "birth" //the animation that will be played when the unit is created
        private constant integer MAX_TYPES = 3  //The maximum number of unit types of the spell
        private constant integer MAX_LEVELS = 3 //the maximum number of levels of the spell
    endglobals
    
    
//===========================================================================
//============================GOLEM SETUP====================================
//===========================================================================

    private function GolemTypes takes nothing returns nothing
        //This is to prevent not innitialied arrays. 
        //It is also necessary for array indexing to work properly - don't change.
        set GOLEM_TYPES[0] = 0 
        
        //this sets the golem types. In this case we have 3 golem types
        //for level 1, 2 and 3; and the Golem types that can be spawned for 
        //each level are equal.
        
        //for level 1
        set GOLEM_TYPES[MAX_TYPES * 1 + 1] = 'ngrk'
        set GOLEM_TYPES[MAX_TYPES * 1 + 2] = 'ngst'
        set GOLEM_TYPES[MAX_TYPES * 1 + 3] = 'nggr'
        
        //for level 2
        set GOLEM_TYPES[MAX_TYPES * 2 + 1] = 'ngrk'
        set GOLEM_TYPES[MAX_TYPES * 2 + 2] = 'ngst'
        set GOLEM_TYPES[MAX_TYPES * 2 + 3] = 'nggr'
        
        //for level 3
        set GOLEM_TYPES[MAX_TYPES * 3 + 1] = 'ngrk'
        set GOLEM_TYPES[MAX_TYPES * 3 + 2] = 'ngst'
        set GOLEM_TYPES[MAX_TYPES * 3 + 3] = 'nggr'
        
        //Note that the formula being used is:
        //MAX_TYPES * level + NumberOfGolemType
        //this simulates a 2D array for the Golem Types we can have
    endfunction
    
    private function GolemChances takes nothing returns nothing
        //This is to prevent not innitialied arrays. 
        //It is also necessary for array indexing to work properly - don't change.
        set GOLEM_CHANCES[0] = 0
        
        //this sets the chances each golem has to be spawned.
        //In this case the chances will depend on level. Keeping in mind that
        //NumberOfGolemType 1 is the weaker, we will make him the most commun 
        //golem, and NumberOfGolemType 3 the most rare golem because he is the 
        //strongest. As you will see, chances will depend on the level, we will 
        //increase the chances of have a NumberOfGolemType 3 and decrease the chances
        //of having NumberOfGolemType 1.
        //NOTE: NumberOfGolemType1 + NumberOfGolemType2 + NumberOfGolemType3 = 1.0
        //This is very important for things to work properly.
        
        //for level 1
        set GOLEM_CHANCES[MAX_TYPES * 1 + 1] = 0.5
        set GOLEM_CHANCES[MAX_TYPES * 1 + 2] = 0.3
        set GOLEM_CHANCES[MAX_TYPES * 1 + 3] = 0.2
        
        //for level 2
        set GOLEM_CHANCES[MAX_TYPES * 2 + 1] = 0.4
        set GOLEM_CHANCES[MAX_TYPES * 2 + 2] = 0.4
        set GOLEM_CHANCES[MAX_TYPES * 2 + 3] = 0.2
        
        //for level 3
        set GOLEM_CHANCES[MAX_TYPES * 3 + 1] = 0.4
        set GOLEM_CHANCES[MAX_TYPES * 3 + 2] = 0.3
        set GOLEM_CHANCES[MAX_TYPES * 3 + 3] = 0.3
        
        //Note that the formula being used is:
        //MAX_TYPES * level + NumberOfGolemType
        //this simulates a 2D array for the chances each Golem Type has at each level
    endfunction
    
    private constant function GolemLife takes integer level returns real
        //the amount of time each golem will have, if ChannelGolems() is false
        return level * 20.  
    endfunction

    private constant function ChannelGolems takes integer level returns boolean
        //if true it will make all spawned golems die when the caster stops the channel
        //if false, it allows the golems to have GolemLife() seconds of life and they
        //will not die when the caster stops the channel
        //in this case my golems 20, 40 and 60 seconds of life for each level.
        return false
        
        //example of usage

//        if (level == 3) then
//            return false
//        endif
//        return true

        //in this example the golems will die when the channel ends in level 1 and 2
        //in level 3, the golems will live 60 seconds of life
    endfunction
    
    private constant function GolemsPerCycle takes integer level returns integer
        //the number of golems that will be created each cycle
        return 1 + (level * 0)
    endfunction
    
    private constant function Cycle takes integer level returns real
        //the cycle which will determine when we create golems
        //this means, GolemsPerCycle() golems are created every cycle
        //in this case, we create 1 golem per second (in this case a second 
        //is a cycle)
        return 1. + (level * 0) 
    endfunction
    
//===========================================================================
//============================DUST SETUP=====================================
//===========================================================================
    
    private constant function DummyEffectId takes integer level returns integer
        //the rawcode of the dummy unit that will be dust
        //this is in a function so you can have different effects in different
        //levels
        return 'h000'
    endfunction
    
    private constant function MinRange takes integer level returns real
        //in this case we dont have a minimum range, which means we can 
        //create golems at the center of the circle
        //the minimum range is smaller circle, inside the area of the spell
        //in which golems will not be created
        return 0.
    endfunction
    
    private constant function MaxRange takes integer level returns real
        //this ensures golems are not created outside the AOE of the spell
        //this gives the AOE of the spell
        return 200. + (level * 100)
    endfunction
    
    private constant function CircleCount takes integer level returns integer
        //the number of circles that will be created to give the illusion of the dust
        //effect. The more circles the more realistic, but more CPU will be needed.
        return 3 + level 
    endfunction
    
    private constant function InnerCurcleUnits takes integer level returns integer
        //the number of units that the most inner circle will have
        return level + 5
    endfunction
    
    private constant function InnerCurcleUnitsIncrease takes integer level returns integer
        //the increment of units per circle
        return level + 2
    endfunction
//===========================================================================
//=============================SETUP END=====================================
//===========================================================================

    globals 
        private group GolemInvocationCasters
        private HandleTable activeTable 
    endglobals
    
    private struct MyStruct 
        unit caster
        integer level
        timer cycleTimer 
        real spellLocX
        real spellLocY
        group dummyEffects
        group golems
        
        static method create takes unit caster, real locX, real locY returns MyStruct
            local MyStruct data = MyStruct.allocate()
            
            //set variables about the caster
            set data.caster = caster
            set data.level = GetUnitAbilityLevel(data.caster, AID)
            
            //variables about the location
            set data.spellLocX = locX
            set data.spellLocY = locY
            
            //the timer which will determine when we create golems
            //creates a golem everytime it expires
            set data.cycleTimer = NewTimer()   
            
            //This groups will save the dumy dust effects, so we can kill them 
            //when the caster stops the channeling
            set data.dummyEffects = CreateGroup()
            
            //if we want the golems to die when the caster stops channel
            //then we create this group so we can add all golems to it
            //then we kill the golems when the caster stops the channel
            if (ChannelGolems(data.level)) then
                set data.golems = CreateGroup()
            endif
            
            return data
        endmethod
        
        method onDestroy takes nothing returns nothing
            
            //here we select all units from the group and we kill them all ! =P
            //thus meaning that the dust effects will disappear ! 
            local unit f
            loop
                set f = FirstOfGroup(.dummyEffects)
                exitwhen(f == null)
                call GroupRemoveUnit(.dummyEffects, f)
                call KillUnit(f)
            endloop
            
            //if the variable is true, then golems group was created and it has
            //units. Now we just kill all units it has and we release the group
            //for CSSafety to use one day later
            if (ChannelGolems(.level)) then
                loop
                    set f = FirstOfGroup(.golems)
                    exitwhen(f == null)
                    call GroupRemoveUnit(.golems, f)
                    call KillUnit(f)
            endloop
            
            call DestroyGroup(.golems)
            endif
            
            //since the spell is not active anymore, we clean the Table     
            call activeTable.flush(.caster) 
            
            //the units are not anymore in the active units group.
            call GroupRemoveUnit(GolemInvocationCasters, .caster) 
            
            //releasing the timer and group for CSSafety to use it one day later =D
            call ReleaseTimer(.cycleTimer)
            call DestroyGroup(.dummyEffects)
            
        endmethod
    endstruct
    
//===========================================================================
    private function onStop takes nothing returns boolean
        local MyStruct data
        local unit u = GetTriggerUnit()
        
        //when a unit stops the channel, we verify if that unit is inside the
        //catsers group. If so, than it is because it is a caster casting this spell
        //and so we recover information about him and we make the spell end
        if(IsUnitInGroup(u, GolemInvocationCasters)) then
            //recover the data from the caster
            set data = activeTable[u] 
            
            //now, time to clean the mess once again
            call data.destroy() 
        endif

        set u = null
        
        return false
    endfunction
//===========================================================================
    //Function made by Themerion and adapted by Flame_Phoenix
    //Creates circles of dummy units to give the illusion of the dust effect
    private function createDust takes integer aStruct returns nothing
        local MyStruct data = aStruct
        
        // forPlayer     -> Create the units for which player?
        local player forPlayer = GetOwningPlayer(data.caster)
        
        // innerRadius   -> The radius of the innermost circle
        // outerRadius   -> The radius of the outmost circle
        local real innerRadius = MinRange(data.level)
        local real outerRadius = MaxRange(data.level)
        
        // x and y       -> Center of circles
        local real x = data.spellLocX
        local real y = data.spellLocY

        local real radiusInc = (outerRadius - innerRadius) / I2R(CircleCount(data.level)-1)
        
        //see functions they call
        local integer fxcount = InnerCurcleUnits(data.level)
        local integer fxcountinc = InnerCurcleUnitsIncrease(data.level)
        
        local real phi = 0
        local real phiInc

        loop
            exitwhen (innerRadius + 0.001 >= outerRadius)

            set phi = 0
            set phiInc = 2*bj_PI/I2R(fxcount)
            
            loop
                exitwhen (phi + 0.001 >= 2 * bj_PI)
                //we add the units to a group, so we can kill them when we want ! =P
                call GroupAddUnit(data.dummyEffects, CreateUnit(forPlayer, DummyEffectId(data.level), x + innerRadius * Cos(phi), y + innerRadius * Sin(phi), 180 + Rad2Deg(phi)))
                set phi = phi + phiInc
            endloop
            
            set innerRadius = innerRadius + radiusInc
            set fxcount = fxcount + fxcountinc
        
        endloop
        
        set forPlayer = null
    
    endfunction
//===========================================================================
    //Function made by Vexorian, it selects a random region in a disk. 
    //All regions have the same chance of beeing choosen
    private function GetRandomPointInDisk takes real centerx, real centery, real minradius, real maxradius returns location
        local real d = SquareRoot(GetRandomReal(minradius * minradius, maxradius * maxradius))
        local real a = GetRandomReal(0, 2 * bj_PI)
        return Location(centerx + d * Cos(a), centery + d * Sin(a))
    endfunction
//===========================================================================
    private function createGolems takes nothing returns nothing
        //we get the structure from the timer
        local MyStruct data = MyStruct(GetTimerData(GetExpiredTimer())) 
        
        //variables for us to know where the golems will born
        local location point  
        local real randomX  
        local real randomY 
        
        //just to keep count about how many golems we created
        local integer loopCounter = 0
        
        //variables about the golems
        local unit golem
        local real golemFacing = GetUnitFacing(data.caster)
        
        //Here we spawn the golems 
        loop 
            exitwhen(loopCounter >= GolemsPerCycle(data.level))
                
            set point = GetRandomPointInDisk(data.spellLocX, data.spellLocY, MinRange(data.level), MaxRange(data.level))
            set randomX = GetLocationX(point)
            set randomY = GetLocationY(point)
            
            set golem = PlaceRandomUnit(GOLEM_POOLS[data.level], GetOwningPlayer(data.caster), randomX, randomY, golemFacing)
            call SetUnitAnimation( golem, ANIMATION )
            
            //if ChannelGolems(data.level) is true we add the golem to it 
            //so we can keep track of it and kill it later in the "onDestroy"
            //method
            //else if the variable is false, it means that the group was not
            //created, and we ant the units to have a LifeTime
            if (ChannelGolems(data.level)) then
                call GroupAddUnit(data.golems, golem)
            else
                call UnitApplyTimedLife(golem, 'BTLF', GolemLife(data.level))
            endif
            
            call RemoveLocation(point)
            set point = null
                
            set loopCounter = loopCounter + 1
        endloop
    
    set golem = null

    endfunction
//===========================================================================
    private function Conditions takes nothing returns boolean
        local MyStruct data
        local location spellLoc //the location of the spell
        
        if (GetSpellAbilityId() == AID) then
            //setting variables for the struct
            set spellLoc = GetSpellTargetLoc()
            set data = MyStruct.create(GetTriggerUnit(), GetLocationX(spellLoc), GetLocationY(spellLoc))
            
            //put the struct in the Table, we just use the caster's handle adress as 
            //the key which tells us where in the Table the struct is stored
            set activeTable[data.caster] = data 

            //  we add the casting unit to some sort of "pool"
            call GroupAddUnit(GolemInvocationCasters, data.caster)
            
            //now we create the dusty effect
            call createDust(data)
            
            //we attach the struct to the timer
            call SetTimerData(data.cycleTimer, integer(data))
            call TimerStart(data.cycleTimer, Cycle(data.level), true, function createGolems)
            
            //cleaning up the mess
            call RemoveLocation(spellLoc)
        endif
        
        set spellLoc = null
        
        return false
    endfunction
//===========================================================================
    private function Init takes nothing returns nothing
        //these integers are counters for a loop and will be used later
        local integer i
        local integer j
        
        //here we set up the triggers we will need
        local trigger GolemInvocationTrigger = CreateTrigger(  )
        call TriggerRegisterAnyUnitEventBJ(GolemInvocationTrigger, EVENT_PLAYER_UNIT_SPELL_EFFECT )
        call TriggerAddCondition(GolemInvocationTrigger, Condition( function Conditions ) )
        
        set GolemInvocationTrigger = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ(GolemInvocationTrigger, EVENT_PLAYER_UNIT_SPELL_ENDCAST)
        call TriggerAddCondition(GolemInvocationTrigger,  Condition(function onStop))

        set GolemInvocationTrigger = null
        
        //set our globals
        set activeTable = HandleTable.create() 
        set GolemInvocationCasters = CreateGroup() 

        //now we will Create UnitPools using loops and the
        //counters. 
        
        //we fill the arrays, so we can use them in the loop
        call GolemTypes()
        call GolemChances()
        
        set i = 0   //The outer counter
        set j = 0   //The inner counter
        
        //in the outer loop, we create an UnitPool for each level
        loop
            exitwhen(i > MAX_LEVELS)
            set GOLEM_POOLS[i] = CreateUnitPool()
            
            //this inner loop adds a unit to the units pool array and gives it a "weight".
            //"weights" are the chances a unit has to be choosen, the bigger the weight the 
            //chances you'll have to pick that unit
            set j = 0
            loop
                exitwhen(j > MAX_TYPES)
                call UnitPoolAddUnitType(GOLEM_POOLS[i], GOLEM_TYPES[MAX_TYPES * i + j], GOLEM_CHANCES[MAX_TYPES * i + j])
                set j = j + 1
            endloop
            
            set i = i + 1
        endloop
        
    endfunction
endscope 

scope GolemInvocation initializer Init

    //Gloabls for the spell's core, don't change
    globals 
        private integer array GOLEM_TYPES   
        private real array GOLEM_CHANCES
        private unitpool array GOLEM_POOLS
    endglobals
    
//===========================================================================
//=============================SETUP START===================================
//===========================================================================

    globals
        private constant integer AID = 'A001'   //the rawcode of the ability
        private constant string ANIMATION = "birth" //the animation that will be played when the unit is created
        private constant integer MAX_TYPES = 3  //The maximum number of unit types of the spell
        private constant integer MAX_LEVELS = 3 //the maximum number of levels of the spell
    endglobals
    
    private type levels extends integer array[MAX_LEVELS + 1]   //compile error, wrong size definition !
    private type golem_types extends levels array[MAX_TYPES + 1]
    private type golem_chances extends levels array[MAX_TYPES + 1]
//===========================================================================
//============================GOLEM SETUP====================================
//===========================================================================
    
    private function GolemTypes2 takes nothing returns nothing
        local golem_types types = golem_types.create()
        
        //This is to prevent not innitialied arrays. 
        //It is also necessary for array indexing to work properly - don't change.
        set types[0] = levels.create()
        set types[0][0] = 0
        set types[0][1] = 0
        set types[0][2] = 0
        set types[0][3] = 0
        
        //for level 1
        set types[1] = levels.create()
        set types[1][0] = 0
        set types[1][1] = 'ngrk'
        set types[1][2] = 'ngst'
        set types[1][3] = 'nggr'
        
        //for level 2
        set types[2] = levels.create()
        set types[2][0] = 0
        set types[2][1] = 'ngrk'
        set types[2][2] = 'ngst'
        set types[2][3] = 'nggr'
        
        //for level 3
        set types[3] = levels.create()
        set types[3][0] = 0
        set types[3][1] = 'ngrk'
        set types[3][2] = 'ngst'
        set types[3][3] = 'nggr'
        
        
        //I am lost with the loops !
        //this is the example in vJASS documentation, can some one 
        //tell me if I did things correctly ?
        
//        type iar extends integer array[3]
//        type iar_ar extends iar array[3]
//        function test takes nothing returns arsample
//            local iar_ar r=iar_ar.create()
//            local integer i=0
//            local integer j
//            loop
//                exitwhen i==iar_ar.size //holds size of the array type
//                set r[i]=iar.create()
//                set j=0
//                loop
//                    exitwhen j==iar.size
//                    set r[i][j]=j*i
//                    set j=j+1
//                endloop
//
//            set i=i+1
//        endloop
//    return r
//    endfunction

    endfunction
    
    private function GolemTypes takes nothing returns nothing
        //This is to prevent not innitialied arrays. 
        //It is also necessary for array indexing to work properly - don't change.
        set GOLEM_TYPES[0] = 0 
        
        //this sets the golem types. In this case we have 3 golem types
        //for level 1, 2 and 3; and the Golem types that can be spawned for 
        //each level are equal.
        
        //for level 1
        set GOLEM_TYPES[MAX_TYPES * 1 + 1] = 'ngrk'
        set GOLEM_TYPES[MAX_TYPES * 1 + 2] = 'ngst'
        set GOLEM_TYPES[MAX_TYPES * 1 + 3] = 'nggr'
        
        //for level 2
        set GOLEM_TYPES[MAX_TYPES * 2 + 1] = 'ngrk'
        set GOLEM_TYPES[MAX_TYPES * 2 + 2] = 'ngst'
        set GOLEM_TYPES[MAX_TYPES * 2 + 3] = 'nggr'
        
        //for level 3
        set GOLEM_TYPES[MAX_TYPES * 3 + 1] = 'ngrk'
        set GOLEM_TYPES[MAX_TYPES * 3 + 2] = 'ngst'
        set GOLEM_TYPES[MAX_TYPES * 3 + 3] = 'nggr'
        
        //Note that the formula being used is:
        //MAX_TYPES * level + NumberOfGolemType
        //this simulates a 2D array for the Golem Types we can have
    endfunction

    globals
        private constant integer MAX_TYPES=3
        private constant integer MAX_LEVELS=3
    endglobals

    private keyword golemType
    private keyword golemChance
    private function Calibrate takes nothing returns nothing
        set golemType[0]='ngrk'
        set golemType[1]='ngst'
        set golemType[2]='nggr'

        //level 1 chances
        set golemChance[1][0]=1.0
        set golemChance[1][1]=0.0
        set golemChance[1][2]=0.0
        //level 2 chances
        set golemChance[2][0]=0.75
        set golemChance[2][1]=0.25
        set golemChance[2][2]=0.0
        //level 3 chances
        set golemChance[3][0]=0.25
        set golemChance[3][1]=0.50
        set golemChance[3][2]=0.25
    endfunction

//end of calibration section

    private type chancePerType extends real array[MAX_TYPES]
    globals
        private integer array golemType
        private chancePerType array golemChance
    endglobals

    private function Init takes nothing returns nothing
        local integer i = 1 //we don't init index 0
        loop
            exitwhen i> MAX_LEVELS
            set golemChance[i]=chancePerType.create()
            set i = i+1
        endloop
        call Calibrate()
    endfunction

scope GolemInvocation initializer Init

//Gloabls for the spell's core, don't change
    globals 
        private integer array golemType   
        private real array golemChances
        private unitpool array GOLEM_POOLS
    endglobals
//===========================================================================
//=============================SETUP START===================================
//===========================================================================

    globals
        private constant integer AID = 'A001'   //the rawcode of the ability
        private constant string ANIMATION = "birth" //the animation that will be played when the unit is created
        private constant integer MAX_TYPES = 3  //The maximum number of unit types of the spell
        private constant integer MAX_LEVELS = 3 //the maximum number of levels of the spell
    endglobals
    
//    private keyword golemType
//    private keyword golemChance
    
    private type chancesPerType extends real array[MAX_TYPES]
//===========================================================================
//============================GOLEM SETUP====================================
//===========================================================================
    
    private function Calibrate takes nothing returns nothing
        set golemType[0] = 'ngrk'
        set golemType[1] = 'ngst'
        set golemType[2] = 'nggr'
        
        //level 1 chances
        set golemChances[1][0] = 0.5    //syntax error !!
        set golemChances[1][1] = 0.3    //syntax error !!
        set golemChances[1][2] = 0.2    //syntax error !!
        
        //level 2 chances
        set golemChances[2][0] = 0.4    //syntax error !!
        set golemChances[2][1] = 0.4    //you get the point...
        set golemChances[2][2] = 0.2
        
        //level 3 chances
        set golemChances[3][0] = 0.4
        set golemChances[3][1] = 0.3
        set golemChances[3][2] = 0.3
    endfunction
    
    private constant function GolemLife takes integer level returns real
        //the amount of time each golem will have, if ChannelGolems() is false
        return level * 20.  
    endfunction

    private constant function ChannelGolems takes integer level returns boolean
        //if true it will make all spawned golems die when the caster stops the channel
        //if false, it allows the golems to have GolemLife() seconds of life and they
        //will not die when the caster stops the channel
        //in this case my golems 20, 40 and 60 seconds of life for each level.
        return false
        
        //example of usage

//        if (level == 3) then
//            return false
//        endif
//        return true

        //in this example the golems will die when the channel ends in level 1 and 2
        //in level 3, the golems will live 60 seconds of life
    endfunction
    
    private constant function GolemsPerCycle takes integer level returns integer
        //the number of golems that will be created each cycle
        return 1 + (level * 0)
    endfunction
    
    private constant function Cycle takes integer level returns real
        //the cycle which will determine when we create golems
        //this means, GolemsPerCycle() golems are created every cycle
        //in this case, we create 1 golem per second (in this case a second 
        //is a cycle)
        return 1. + (level * 0) 
    endfunction

//INSIDE THE INIT FUNCION

//now we will Create UnitPools using loops and the counters. 
        set i = 1   //The outer counter
        
        //in the outer loop, we create an UnitPool for each level
        loop
            exitwhen(i > MAX_LEVELS)
            set golemChances[i] = chancesPerType.create()
            set GOLEM_POOLS[i] = CreateUnitPool()
            set i = i + 1
        endloop
        
        call Calibrate()
        
        set i = 0
        loop
            exitwhen( i > MAX_TYPES)
            call UnitPoolAddUnitType(GOLEM_POOLS[i + 1], golemType[i], golemChances[i])
            set i = i + 1
        endloop

        set golemChances[1][0] = 0.5    //syntax error !!
        set golemChances[1][1] = 0.3    //syntax error !!
        set golemChances[1][2] = 0.2    //syntax error !!
        
        //level 2 chances
        set golemChances[2][0] = 0.4    //syntax error !!
        set golemChances[2][1] = 0.4    //you get the point...
        set golemChances[2][2] = 0.2
        
        //level 3 chances
        set golemChances[3][0] = 0.4
        set golemChances[3][1] = 0.3
        set golemChances[3][2] = 0.3