Triggers

//TESH.scrollpos=0
//TESH.alwaysfold=0
library CSCache initializer InitCSCache

    //*************************************************************************************************
    //*                                                                                               *
    //* CSCache 14.6                       http://wc3campaigns.net/vexorian                           *
    //* ¯¯¯¯¯¯¯                                                                                       *
    //*    From attach variables to Dynamic Arrays, not forgetting the tables,                        *
    //* CSData and the Pools, this is a pack of storage options                                       *
    //*                                                                                               *
    //*************************************************************************************************

    //=================================================================================================
    // CSCache globals:
    //
    globals

        gamecache               cs_cache   = null
        integer array           cs_array1
        integer array           cs_array3
        integer array           cs_array2
        integer array           cs_freeindexes
        integer array           cs_pairx
        integer array           cs_pairy
        integer array           cs_freepairs


        gamecache               udg_cscache = null //udg_ for compat!

    endglobals

    //=================================================================================================
    // Note: //! define macro commands are used accross the script, they are usually to be parsed by
    // WEHelper, no //! define parser is really required, but if present it would improve the
    // performance of some calls.
    //

    //=================================================================================================
    // a.k.a H2I, changed name to CS_H2I to prevent conflicts with other systems (I intended this
    // system to be easy to copy
    //
    function CS_H2I takes handle h returns integer
        return h
        return 0
    endfunction

    //==================================================================================================
    // Bunch of other return bug exploiters
    //
    function CS_i2r takes integer i returns real
        return i
        return 0.
    endfunction

    function CS_h2r takes handle h returns real
        return h
        return 0.
    endfunction

    function CS_r2i takes real r returns integer
        return r
        return 0
    endfunction

    function CS_lx takes location l returns location
        return GetLocationX(l)
        return null
    endfunction

    function CS_ly takes location l returns location
        return GetLocationY(l)
        return null
    endfunction


    function CS_i2l takes integer l returns location
        return l
        return null
    endfunction

    //==================================================================================================
    // location linked list kit
    // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
    // Thanks: Pipedream | No thanks: Blizzard (for lame bug)
    //
    // It is a great irony, but locations are only useful when you don't use them as points but as 
    // structs thanks to the return bug. They only allow 2 values so they are limited in comparission
    // to gamecache and arrays (see bellow) still useful for single linked lists.
    //
    // These functions are what I call enough to use locations as single list nodes, X holds values and
    // Y can just hold a location (or real) . The Get functions use bj globals to fix an odd operator
    // bug that can happen after converting pointer to real into pointer to integer. 
    //
    // The Set functions can be replaced by the Location() constructor, the MoveLocation() native and
    // the return bug exploiters up there.
    //

    //===================================================================================================
    // Constructors
    //
    function Location_IntLoc takes integer x , location y returns location
       return Location(CS_i2r(x),CS_h2r(y))
    endfunction
    //! define Location_IntLoc(x,y) Location(CS_i2r(x),CS_h2r(y))
    function Location_ObjectLoc takes handle x , location y returns location
       return Location(CS_h2r(x),CS_h2r(y))
    endfunction
    //! define Location_ObjectLoc(x,y) Location(CS_h2r(x),CS_h2r(y))
    function Location_LocLoc takes handle x , location y returns location
       return Location(CS_h2r(x),CS_h2r(y))
    endfunction
    //! define Location_LocLoc(x,y) Location(CS_h2r(x),CS_h2r(y))
    function Location_RealLoc takes real x , location y returns location
       return Location(x,CS_h2r(y))
    endfunction
    //! define Location_RealLoc(x,y) Location(x,CS_h2r(y))

    //====================================================================================================
    // Combined assigments
    //
    function SetLocation_IntLoc takes location loc, integer x , location y returns nothing
       call MoveLocation(loc,CS_i2r(x),CS_h2r(y))
    endfunction
    //! define SetLocation_IntLoc(loc,x,y) MoveLocation(loc,CS_i2r(x),CS_h2r(y))
    function SetLocation_ObjectLoc takes location loc, handle x , location y returns nothing
       call MoveLocation(loc,CS_h2r(x),CS_h2r(y))
    endfunction
    //! define SetLocation_ObjectLoc(loc,x,y) MoveLocation(loc,CS_h2r(x),CS_h2r(y))
    function SetLocation_LocLoc takes location loc, handle x , location y returns nothing //Funny name
       call MoveLocation(loc,CS_h2r(x),CS_h2r(y))
    endfunction
    //! define SetLocation_LocLoc(loc,x,y) MoveLocation(loc,CS_h2r(x),CS_h2r(y))
    function SetLocation_RealLoc takes location loc, real x , location y returns nothing
       call MoveLocation(loc,x,CS_h2r(y))
    endfunction
    //! define SetLocation_RealLoc(loc,x,y) MoveLocation(loc,x,CS_h2r(y))



    //===================================================================================================
    // Lack of SetLocationX / SetLocationY natives is kind of lame
    //
    function SetLocationX_Object takes location loc, handle val returns nothing
        call MoveLocation(loc,CS_h2r(val),GetLocationY(loc))
    endfunction
    // Notice how define SetLocationX_Object(loc,v) MoveLocation(loc,CS_h2r(v),GetLocationY(loc))
    // would have a chance of messing sometimes since it has 2 loc in the result.
    function SetLocationX_Loc takes location loc, location val returns nothing //just name candy
        call MoveLocation(loc,CS_h2r(val),GetLocationY(loc))
    endfunction
    function SetLocationX_Real takes location loc, real val returns nothing
        call MoveLocation(loc,val,GetLocationY(loc))
    endfunction
    function SetLocationX_Int takes location loc, integer val returns nothing
        call MoveLocation(loc,CS_i2r(val),GetLocationY(loc))
    endfunction

    function SetLocationY_Loc takes location loc, location val returns nothing
        call MoveLocation(loc,GetLocationX(loc),CS_h2r(val))
    endfunction

    //==================================================================================================
    // All right, crazyness that started with Attacheable variables, and had to continue with everything
    // from tables, arrays and now this. Sorry I can't help itç
    //
    // The good thing about these functions is that they are safe, you won't deal with real->(int/handle)
    // conversion related bugs thanks to the use of bj variables these functions do
    //
    function GetLocationX_Loc takes location loc returns location
        set bj_enumDestructableCenter=CS_lx(loc)
        return bj_enumDestructableCenter
    endfunction
    function GetLocationY_Loc takes location loc returns location
        set bj_enumDestructableCenter=CS_ly(loc)
        return bj_enumDestructableCenter
    endfunction
    function GetLocationX_Int takes location loc returns integer
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
    endfunction
    function GetLocationX_Unit takes location loc returns unit
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Item takes location loc returns item
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Effect takes location loc returns effect
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Lightning takes location loc returns lightning
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Widget takes location loc returns widget
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Object takes location loc returns handle
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Rect takes location loc returns rect
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Region takes location loc returns region
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_TimerDialog takes location loc returns timerdialog
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Destructable takes location loc returns destructable
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Trigger takes location loc returns trigger
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Timer takes location loc returns timer
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Group takes location loc returns group
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_TriggerAction takes location loc returns triggeraction
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Image takes location loc returns image
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Ubersplat takes location loc returns ubersplat
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    function GetLocationX_Sound takes location loc returns sound
        set bj_forLoopAIndex=CS_r2i(GetLocationX(loc))
     return bj_forLoopAIndex
     return null
    endfunction
    //
    //That should be all we needed to abuse Locations, Love lists.
    //



    // CSCache initializer :
    function InitCSCache takes nothing  returns nothing
        call FlushGameCache(InitGameCache("cscache"))
        set cs_cache=InitGameCache("cscache")
        set udg_cscache = cs_cache
        call ExecuteFunc("InitArrayIndexes")
        call ExecuteFunc("Pool_SetupCharMap")
    endfunction


    //==================================================================================================
    // CSData
    // ¯¯¯¯¯¯
    // CSDatas are like UserData in units and items, they are faster than gamecache unless you have more
    // than 8191 handles in your map. In that case it would be a little slower but only for those
    // handles. And if you have more than 8191 handles your map is too slow already anyways.
    //
    // Notice that for public spells or systems to be distributed you should only use these
    // for private objects (those who the mapper would never have access to) If you are making something
    // for your map you can use them wherever you want.
    //
    // Best to be used in conjunction to CSArrays so you just specify an array id for a handle.
    //
    // DO NOT USE THIS ON THESE HANDLE TYPES: -lightning, -ubersplat, -image, -texttag,
    //                                        -any 'argument' handle (like playerstate, damagetype, etc)
    //
    function SetCSData takes handle h, integer v returns nothing
     local integer i=CS_H2I(h)-0x100000
        if (i>=8191) then
            call StoreInteger(cs_cache,"csdata",I2S(i),v)
        else
            set cs_array3[i]=v
        endif
    endfunction

    function GetCSData takes handle h returns integer
     local integer i=CS_H2I(h)-0x100000
        if (i>=8191) then
            //can't use Get without Set
            return GetStoredInteger(cs_cache,"csdata",I2S(i))
        endif
     return cs_array3[i]
    endfunction

    //=================================================================================================================
    // CS Pairs
    // ¯¯¯¯¯¯¯¯
    // This is a sub system to assist csarrays, you can use them but CSArrays of size 2 have the same functionality
    // although cspairs are be faster their space is limited and will start using gamecache if abused
    //
    function NewPair takes integer x, integer y returns integer
     local integer i
     
       if (cs_freepairs[0]==0) then
           set cs_freepairs[8190]=cs_freepairs[8190]+1
           set i= cs_freepairs[8190]
       else
           set i= cs_freepairs[cs_freepairs[0]]
           set cs_freepairs[0]=cs_freepairs[0]-1
       endif
       if (i>=8189) then //because we can only recycle up to 8189 (free pairs array uses indexes 0 and 8190 for other purposes)
           call StoreInteger(cs_cache,"pairx",I2S(i),x)
           call StoreInteger(cs_cache,"pairy",I2S(i),y)
       else
           set cs_pairx[i]=x
           set cs_pairy[i]=y

       endif
     return i
    endfunction

    function DestroyPair takes integer id returns nothing
        if (id>=8189) then
            call FlushStoredInteger(cs_cache,"pairx",I2S(id))
            call FlushStoredInteger(cs_cache,"pairy",I2S(id))
        else
            set cs_freepairs[0]=cs_freepairs[0]+1
            set cs_freepairs[cs_freepairs[0]] = id
        endif
    endfunction

    function SetPairXY takes integer id, integer x, integer y returns nothing
        if (id>=8189) then
            call StoreInteger(cs_cache,"pairx",I2S(id),x)
            call StoreInteger(cs_cache,"pairy",I2S(id),y)

        else
            set cs_pairx[id]=x
            set cs_pairy[id]=y
        endif
    endfunction

    function SetPairX takes integer id, integer x returns nothing
        if (id>=8189) then
            call StoreInteger(cs_cache,"pairx",I2S(id),x)
        else
            set cs_pairx[id]=x
        endif
    endfunction

    function SetPairY takes integer id, integer y returns nothing
        if (id>=8189) then
            call StoreInteger(cs_cache,"pairy",I2S(id),y)
        else
            set cs_pairy[id]=y
        endif
    endfunction

    function GetPairX takes integer id returns integer
        if (id>=8189) then
            return GetStoredInteger(cs_cache,"pairy",I2S(id))
        endif
     return cs_pairx[id]
    endfunction
    function GetPairY takes integer id returns integer
        if (id>=8189) then
            return GetStoredInteger(cs_cache,"pairx",I2S(id))
        endif
     return cs_pairy[id]
    endfunction





    //=================================================================================================================
    // CS Dynamic Arrays
    // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
    // Thanks: Pipedream, Peppar
    //
    // We can now create arrays in game! , also pass them as arguments or return values!
    // a 1 length array is a pointer!
    //
    function Array_TryFree takes nothing returns nothing
     local integer i
     local integer N=cs_array1[0]
     local integer k
     local boolean cleaned=false

     local integer loc

     local integer q
     local integer r
        


            set i=cs_array1[146]
            if (i>144) then
                call TimerStart(GetExpiredTimer(),60.,false,function Array_TryFree)
                return
            endif

            set loc=cs_freeindexes[i]
            set q=0
            loop
                exitwhen (loc==0)
    	    // we could just have used:
                    //set k=GetPairX(loc)
                    //set r=GetPairY(loc) But it is slower than direct usage:

                if (loc>=8192) then
    	        set k=GetStoredInteger(cs_cache,"pairx",I2S(loc))
    		set r=GetStoredInteger(cs_cache,"pairy",I2S(loc))
    	    else
    	        set k=cs_pairx[loc]
    		set r=cs_pairy[loc]
    	    endif

                if (k+i-1==N) then


                    //we found one we can remove from the list

                    set cleaned=true
                    //decrement N
                    
                    set N=k-2

                    //Remove from the list:
                    if (q==null) then
                        //That was the first, update the array as well
                        set cs_freeindexes[i]=r
                    else
                        //Update the next of the previous one
                        //We could use : call SetPairY(q,,r) but it is slower
    		    if (q>=8189) then
    		        call StoreInteger(cs_cache,"pairy",I2S(q),r)
                        else
    			set cs_pairy[q]=r
    		    endif


                    endif
                    if (r==null) then
                        //This was the last one, update it in the array as well
                        set cs_freeindexes[i+4096]=q
                    endif
                    
                    call DestroyPair(loc)
                    set loc=q
                endif
                set q=loc
                set loc=r
            endloop
           
            if (cleaned) then
                set cs_array1[0]=N
                set cs_array1[146]=1
            else
                set cs_array1[146]=cs_array1[i+1]
            endif
     call TimerStart(GetExpiredTimer(),0.2,false,function Array_TryFree)

    endfunction

    function InitArrayIndexes2 takes nothing returns nothing
     local integer i=0
        loop
            exitwhen (i==8191)
            set cs_pairx[i]=777
            set cs_pairy[i]=777
            set i=i+1
        endloop
     
    endfunction


    function InitArrayIndexes takes nothing returns nothing
     local integer i=0
     local integer a=1
     local integer b=1
     local integer c


        //By placing 777 there instead of 0 it is easier to recognize non correctly initialized bugs
        loop
            exitwhen (i== 8191)
            set cs_array1[i]=777
            set cs_array2[i]=777
            set cs_array3[i]=777
            //set cs_pairx[i]=777
            //set cs_pairy[i]=777
            set i=i+1
        endloop
        call ExecuteFunc("InitArrayIndexes2")


        set cs_freeindexes[0]=0 //The stack for the table indexes.
        set cs_freepairs[0]=0
        set cs_freepairs[8190]=0
        set i=1
        loop
            set c=a+b
            set a=b
            set b=c
            exitwhen (b>144) //max size is 144
            set cs_freeindexes[b]=0 //the first of the list
            set cs_freeindexes[b+4096]=0 //the last of the list
            loop
                exitwhen (i>b)
                set cs_array1[i]=b
                set i=i+1
            endloop
            
        endloop
        set cs_array1[i]=b //i is 145
        set cs_array1[146]=1
        set cs_array1[147]=101 //initial table index is 101
        set cs_array1[0]=147
        //index 0: Last used index
        // 1 to 145 : Fibonacci sequence
        // 146 : last check
        // 147 : Table indexes check
       
        //This has a good chance to compress the thing when necesary
        call TimerStart(CreateTimer(),60.,false,function Array_TryFree)

    endfunction

    //=============================================================================================
    // Create an array of size, max size is 144, if doinit is true it will put a bunch of zeros
    // in the indexes
    //
    function NewArray takes integer size, boolean doinit returns integer
     local integer i
     local integer rsize=cs_array1[size]
     local integer loc

        set loc=cs_freeindexes[rsize]
        if (loc!=0) then

            set cs_freeindexes[rsize]= GetPairY(loc)
            if (cs_freeindexes[rsize]==0) then
                set cs_freeindexes[4096+rsize]=0
            endif
            set i=GetPairX(loc)
            call DestroyPair(loc)

            if (i==0) then
                //this code was probably a good idea when we used locations for the free indexes list, now we use pairs which should not ever
                //do this unless someone modiffied the pair array incorrectly
            
                call BJDebugMsg("Caster System: Unexpected error (5): corrupt stack, attempt to recover "+I2S(rsize))
                // recovering involves forgetting about the stack which got corrupted and start again from zero, it will leak
                // and probably get slow due to usage of gamecache but it is better than the problems that a corrupt stack might cause
                set cs_freeindexes[rsize]=0
                set cs_freeindexes[4096+rsize]=0
                
                
                return NewArray(size,doinit)
            endif

        else
            
            //sz  i   i+1   i+2
            //[ ][   ][    ][   ]
        
            set i=cs_array1[0]+2
            set cs_array1[0]=i+rsize-1

        endif

        //It used to store size in the index equal to the array's id
        // but that required the get/set functions to increment 1 in every index
        // calculation. Instead, making size the previous index to the array works
        if (i<=8191) then
            set cs_array1[i-1]=size
        elseif (i<=16382) then
            set cs_array2[i-8192]=size
        else
            call StoreInteger(cs_cache,I2S(-i),"size",size)
        endif

       
        if (not doinit) then
            return i
        endif
        
        //    3
        //[i][i+1][i+2]

        set size=i+size-1
        if (size>=16382) then
            set size=16381
        endif
        loop
            exitwhen (size<i) or (size<8191)
            set cs_array2[size-8191]=0
            set size=size-1
        endloop
        loop
            exitwhen (size<i)
            set cs_array1[size]=0
            set size=size-1
        endloop
        
        //call DisplayTextToPlayer(GetLocalPlayer(),0,0,I2S(i))

     return i
    endfunction


    //===============================================================================================================
    // Remember to destroy arrays when you no longer need them, else new arrays will get slower after a bunch of 
    // arrays are active
    //
    function DestroyArray takes integer id returns nothing
     local integer L
     local integer loc
    // local string k=I2S(-id)
     local integer lstpace

        if (id<=8191) then
            set L=cs_array1[cs_array1[id-1]]
        elseif (id<=16382) then
            set L=cs_array1[cs_array2[id-8191]]
        else
            set L=cs_array1[GetStoredInteger(cs_cache,I2S(-id),"size")]
            //No way you are gonna call DestroyArray without calling
           //NewArray first, so we can use the gamecache variable directly instead

        endif
        set lstpace=id+L-1
       call FlushStoredMission(cs_cache,I2S(-id))
      
       if (lstpace>16382) then
       
           if (lstpace==cs_array1[0]) then
               //We just destroyed the array that happens to be at the end of the heap.
               //Just get it back
               set cs_array1[0]=id-2
               set cs_array1[146]=1
           else
               //Add to the last
               set loc=cs_freeindexes[L+4096]
               if (loc==0) then
                   set loc=NewPair(id,0)
                   set cs_freeindexes[L]=loc
                   set cs_freeindexes[L+4096]=loc
               else
                   set cs_freeindexes[L+4096]=  NewPair(id,0)
                   //we could just use: call SetPairY(loc, cs_freeindexes[L+4096] ) //but that's slower
                   if (loc>=8189) then
    	           call StoreInteger(cs_cache,"pairy",I2S(loc), cs_freeindexes[L+4096] )
                   else
                       set cs_pairy[loc]=cs_freeindexes[L+4096]	            
                   endif

               endif


           endif

       elseif (lstpace==cs_array1[0]) then
               //We just destroyed the array that happens to be at the end of the heap.
               //Just get it back
               set cs_array1[0]=id-2
               set cs_array1[146]=1
       else
           set loc=cs_freeindexes[L]
           set cs_freeindexes[L]=NewPair(id,loc)

           if (loc==0) then
               set cs_freeindexes[L+4096]=cs_freeindexes[L]
           endif

       endif

    endfunction

    //================================================================================================================
    // Int Set/Get array usage prototypes.
    //
    // These are the actual functions, the rest are just the result of copy paste, if these functions are updated
    // the other ones should be updated as well (They are just return bugged variations)
    //
    function SetArrayInt takes integer id, integer index, integer val returns nothing
        set index=id+index
        if (index<8191) then
            set cs_array1[index]=val
        elseif (index<16382) then    
            set cs_array2[index-8191]=val
        else
            call StoreInteger(cs_cache,I2S(-id),I2S(index),val)
        endif
    endfunction
    function GetArrayInt takes integer id, integer index returns integer
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
    endfunction


    //================================================================================================================
    // String Set/Get array
    //
    // Due String related return bug issues, these are forced to use gamecache
    //
    function SetArrayString takes integer id, integer index, string val returns nothing
        call StoreString(cs_cache,I2S(-id),I2S(index),val)
    endfunction
    function GetArrayString takes integer id, integer index returns string
     return GetStoredString(cs_cache,I2S(-id),I2S(index))
    endfunction

    //(Boolean is not needed)

    //===================================================================================================
    // Indexes of real types
    //
    function SetArrayReal takes integer id, integer index, real val returns nothing
        set index=id+index
        if (index<8191) then
            set cs_array1[index]=CS_r2i(val)
        elseif (index<16382) then    
            set cs_array2[index-8191]=CS_r2i(val)
        else
            call StoreInteger(cs_cache,I2S(-id),I2S(index),CS_r2i(val))
        endif
    endfunction
    function GetArrayReal takes integer id, integer index returns real
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return 0.0
    endfunction


    //===================================================================================================
    // <Indexes of handle types>
    //
    function SetArrayObject takes integer id, integer index, handle val returns nothing
        set index=id+index
        if (index<8191) then
            set cs_array1[index]=CS_H2I(val)
        elseif (index<16382) then    
            set cs_array2[index-8191]=CS_H2I(val)
        else
            call StoreInteger(cs_cache,I2S(-id),I2S(index),CS_H2I(val))
        endif
    endfunction
    //
    //
    //Yep, I am crazy. But These are FASTER than using the function and a return bug exploiter separatedly.
    function GetArrayObject takes integer id, integer index returns handle
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    function GetArrayWidget takes integer id, integer index returns widget
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    function GetArrayTimer takes integer id, integer index returns timer
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    function GetArrayUnit takes integer id, integer index returns unit
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    function GetArrayLoc takes integer id, integer index returns location
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    function GetArrayTrigger takes integer id, integer index returns trigger
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    function GetArrayTriggerAction takes integer id, integer index returns triggeraction
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    function GetArrayGroup takes integer id, integer index returns group
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    function GetArrayEffect takes integer id, integer index returns effect
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    function GetArrayItem takes integer id, integer index returns item
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    function GetArrayLightning takes integer id, integer index returns lightning
        set index=id+index
        if (index<8191) then
            return cs_array1[index]
        elseif (index<16382) then    
            return cs_array2[index-8191]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),I2S(index))
     return null
    endfunction
    //The rest are not used that much and they are a waste of space instead of a save of speed
    //most of the times. THEY ARE STILL MUCH FASTER THAN GAMECACHE
    function GetArrayRect takes integer id, integer index returns rect
        return GetArrayInt(id,index)
        return null
    endfunction
    function GetArrayRegion takes integer id, integer index returns region
        return GetArrayInt(id,index)
        return null
    endfunction
    function GetArrayTimerDialog takes integer id, integer index returns timerdialog
        return GetArrayInt(id,index)
        return null
    endfunction
    function GetArrayDestructable takes integer id, integer index returns destructable
        return GetArrayInt(id,index)
        return null
    endfunction
    function GetArrayImage takes integer id, integer index returns image
        return GetArrayInt(id,index)
        return null
    endfunction
    function GetArrayUbersplat takes integer id, integer index returns ubersplat
        return GetArrayInt(id,index)
        return null
    endfunction
    function GetArraySound takes integer id, integer index returns sound
        return GetArrayInt(id,index)
        return null
    endfunction
    // </Indexes of handle types>
    // The horror!
    //


    //==========================================================================================================================
    // Returns the size of an array (the specified by player one, not the actual size of it) should be useful.
    //
    function GetArraySize takes integer id returns integer
        if (id<=8191) then
            return cs_array1[id-1]
        elseif (id<=16382) then
            return cs_array2[id-8192]
        endif
     return GetStoredInteger(cs_cache,I2S(-id),"size")
    endfunction


    //===========================================================================================================================
    // Returns an array that is an exact copy of the given array
    //
    function CloneArray takes integer id returns integer
     local integer sz
     local integer i
     local integer sz2
     local integer x
     local integer y

        if (id<=8191) then
            set sz=cs_array1[id-1]
        elseif (id<=16382) then
            set sz=cs_array2[id-8192]
        else
            set sz=GetStoredInteger(cs_cache,I2S(-id),"size")
            //No way you are gonna call DestroyArray without calling
           //NewArray first, so we can use the gamecache variable directly instead

        endif

        set i=NewArray(sz,false)
       
        set sz2=i+sz-1
        set sz=id+sz-1
        set x=i
        set y=id
        loop
            exitwhen ((y>sz) or (y>=8191) or (x>=8191))
            set cs_array1[x]=cs_array1[y]
            set y=y+1
            set x=x+1
        endloop
        loop
            exitwhen ((y>sz) or (y>=8191) or (x>=16382))
            set cs_array2[x-8191]=cs_array1[y]
            set y=y+1
            set x=x+1
        endloop
        loop
            exitwhen ((y>sz) or (y>=8191))
            call StoreInteger(cs_cache,I2S(-i),I2S(x-i),cs_array1[y])
            set x=y+1
            set y=y+1
        endloop
        //...
        loop
            exitwhen ((y>sz) or (y>=16382) or (x>=8191))
            set cs_array1[x]=cs_array2[y-8191]
            set y=y+1
            set x=x+1
        endloop
        loop
            exitwhen ((y>sz) or (y>=16382) or (x>=16382))
            set cs_array2[x-8191]=cs_array2[y-8191]
            set y=y+1
            set x=x+1
        endloop
        loop
            exitwhen ((y>sz) or (y>=16382))
            call StoreInteger(cs_cache,I2S(-i),I2S(x-i),cs_array2[y-8191])
            set y=y+1
            set x=x+1
        endloop
        //...
        loop
            exitwhen ((y>sz) or (x>=8191))
            set cs_array1[x]=GetStoredInteger(cs_cache,I2S(-id),I2S(y-id))
            set y=y+1
            set x=x+1
        endloop
        loop
            exitwhen ((y>sz) or (x>=16382))
            set cs_array2[x-8191]=GetStoredInteger(cs_cache,I2S(-id),I2S(y-id))
            set y=y+1
            set x=x+1
        endloop
        loop
            exitwhen (y>sz)
            call StoreInteger(cs_cache,I2S(-i),I2S(x-i),GetStoredInteger(cs_cache,I2S(-id),I2S(y-id)))
            set y=y+1
            set x=x+1
        endloop
        
     return i
    endfunction



    //==================================================================================================
    // Attachable vars : Attacheable variables are what most other people call Handle Variables, they
    // allow to relate data with any handle, using a label, and its value, the stuff auto flushes if
    // the value is 0, false, "", or null .
    //
    // Differences between Attacheable variables and "Local Handle Variables" :
    // - The names of the functions
    // - The name of the function group does not cause confusion, it is difficult to say: 
    //   "you should set local handle variables to null at the end of a function" since
    //   it sounds as if you were talking about the "Local Handle Variables"
    // - And can work together with Tables.
    // 
    // Gamecache stuff are NOT Case Sensitive, don't ever use "" for label (Crashes game!)
    //
    //
    // Although locations and dynamic arrays are faster than gamecache, gamecache still keeps the flexibility
    // Best thing to do in my opinion is to combine these options. By combining you can acquire gamecache
    // flexibility and arrays/locs speed to solve a problem
    //

    //============================================================================================================
    // For integers
    //
    function AttachInt takes handle h, string label, integer x returns nothing
        if x==0 then
            call FlushStoredInteger(cs_cache,I2S(CS_H2I(h)),label)
        else
            call StoreInteger(cs_cache,I2S(CS_H2I(h)),label,x)
        endif
    endfunction
    function GetAttachedInt takes handle h, string label returns integer
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
    endfunction

    //=============================================================================================================
    function AttachReal takes handle h, string label, real x returns nothing
         if x==0 then
            call FlushStoredReal(cs_cache,I2S(CS_H2I(h)),label)
        else
            call StoreReal(cs_cache,I2S(CS_H2I(h)),label,x)
        endif
    endfunction
    function GetAttachedReal takes handle h, string label returns real
        return GetStoredReal(cs_cache,I2S(CS_H2I(h)),label)
    endfunction

    //=============================================================================================================
    function AttachBoolean takes handle h, string label, boolean x returns nothing
        if not x then
            call FlushStoredBoolean(cs_cache,I2S(CS_H2I(h)),label)
        else
            call StoreBoolean(cs_cache,I2S(CS_H2I(h)),label,x)
        endif
    endfunction
    function GetAttachedBoolean takes handle h, string label returns boolean
        return GetStoredBoolean(cs_cache,I2S(CS_H2I(h)),label)
    endfunction

    //=============================================================================================================
    function AttachString takes handle h, string label, string x returns nothing
        if ((x=="") or (x==null)) then
            call FlushStoredString(cs_cache,I2S(CS_H2I(h)),label)
        else
            call StoreString(cs_cache,I2S(CS_H2I(h)),label,x)
        endif
    endfunction
    function GetAttachedString takes handle h, string label returns string
        return GetStoredString(cs_cache,I2S(CS_H2I(h)),label)
    endfunction

    //=============================================================================================================
    function AttachObject takes handle h, string label, handle x returns nothing
        if (x==null) then
            call FlushStoredInteger(cs_cache,I2S(CS_H2I(h)),label)
        else
            call StoreInteger(cs_cache,I2S(CS_H2I(h)),label,CS_H2I(x))
        endif
    endfunction
    function GetAttachedObject takes handle h, string label returns handle
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedWidget takes handle h, string label returns widget
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedRect takes handle h, string label returns rect
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedRegion takes handle h, string label returns region
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedTimerDialog takes handle h, string label returns timerdialog
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedUnit takes handle h, string label returns unit
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedItem takes handle h, string label returns item
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedEffect takes handle h, string label returns effect
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedDestructable takes handle h, string label returns destructable
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedTrigger takes handle h, string label returns trigger
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedTimer takes handle h, string label returns timer
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedGroup takes handle h, string label returns group
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedTriggerAction takes handle h, string label returns triggeraction
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedLightning takes handle h, string label returns lightning
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedImage takes handle h, string label returns image
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedUbersplat takes handle h, string label returns ubersplat
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedSound takes handle h, string label returns sound
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction
    function GetAttachedLoc takes handle h, string label returns location
        return GetStoredInteger(cs_cache, I2S(CS_H2I(h)), label)
        return null
    endfunction


    //============================================================================================================
    function CleanAttachedVars takes handle h returns nothing
        call FlushStoredMission(cs_cache,I2S(CS_H2I(h)))
    endfunction
    //! define CleanAttachedVars(h) FlushStoredMission(cs_cache,I2S(CS_H2I(h)))

    //============================================================================================================
    // Left for compat
    function CleanAttachedVars_NoSets takes handle h returns nothing
        call FlushStoredMission(cs_cache,I2S(CS_H2I(h)))
    endfunction
    //! define CleanAttachedVars_NoSets(h) FlushStoredMission(cs_cache,I2S(CS_H2I(h)))


    //=============================================================================================
    // Tables
    //
    // Tables are lame, the real name would be hash tables, they are just abbreviated usage
    // of gamecache natives with the addition that you can also Copy the values of a table to
    // another one, but don't expect it to be automatic, it must use a FieldData object to know
    // which fields and of wich types to copy, Copying a table to another, with a lot of Fields,
    // should surelly be lag friendly.
    //
    // The other thing about tables is that I can say that the Attached variables of a handle work
    // inside a table and GetAttachmentTable which is just return bug and I2S , works to allow you
    // to manipulate a handle's attached variables through a table.
    //
    // NewTable and DestroyTable were created to allow to create tables in the fly, but you can
    // simply use strings for tables, but place the table names should be between "("")" for example
    // "(mytable)" to avoid conflicts with other caster system stuff.
    //
    function NewTableIndex takes nothing returns integer
     local integer loc=cs_freeindexes[0]
     local integer i
        if (loc!=0) then
            set i=GetPairX(loc)
            set cs_freeindexes[0]=GetPairY(loc)
            call DestroyPair(loc)

            return i
        endif
        set i=cs_array1[147]+1
        set cs_array1[147]=i

     return i
    endfunction
    function NewTable takes nothing returns string
     local integer loc=cs_freeindexes[0]
     local integer i
        if (loc!=0) then
            set i=GetPairX(loc)
            set cs_freeindexes[0]=GetPairY(loc)
            call DestroyPair(loc)

            return I2S(i)
        endif
        set i=cs_array1[147]+1
        set cs_array1[147]=i

     return I2S(i)
    endfunction
    function GetAttachmentTable takes handle h returns string
        return I2S(CS_H2I(h))
    endfunction
    //! define GetAttachmentTable(h) I2S(CS_H2I(h))

    //============================================================================================================
    function DestroyTable takes string table returns nothing
     local integer i=S2I(table)
     local integer n
         call FlushStoredMission(cs_cache,table)
         if ((i>100) and (i<1000000)) then //All right, more than 1000000 tables is just wrong.
             if (i==cs_array1[147]) then
                 set cs_array1[147]=cs_array1[147]-1
             else
                 set cs_freeindexes[0]=  NewPair(i,cs_freeindexes[0])
             endif
         endif

    endfunction

    //============================================================================================================
    function ClearTable takes string table returns nothing
         call FlushStoredMission(cs_cache,table)
    endfunction


    //============================================================================================================
    function SetTableInt takes string table, string field, integer val returns nothing
        if (val==0) then
            call FlushStoredInteger(cs_cache,table,field)
        else
            call StoreInteger(cs_cache,table,field,val)
        endif
    endfunction
    function GetTableInt takes string table, string field returns integer
        return GetStoredInteger(cs_cache,table,field)
    endfunction
    //! define GetTableInt(table,field) GetStoredInteger(cs_cache,table,field)

    //============================================================================================================
    function SetTableReal takes string table, string field, real val returns nothing
        if (val==0) then
            call FlushStoredReal(cs_cache,table,field)
        else
            call StoreReal(cs_cache,table,field,val)
        endif
    endfunction
    function GetTableReal takes string table, string field returns real
        return GetStoredReal(cs_cache,table,field)
    endfunction
    //! define GetTableReal(table,field) GetStoredReal(cs_cache,table,field)

    //============================================================================================================
    function SetTableBoolean takes string table, string field, boolean val returns nothing
        if (not(val)) then
            call FlushStoredBoolean(cs_cache,table,field)
        else
            call StoreBoolean(cs_cache,table,field,val)
        endif
    endfunction
    function GetTableBoolean takes string table, string field returns boolean
        return GetStoredBoolean(cs_cache,table,field)
    endfunction
    //! define GetTableBoolean(table,field) GetStoredBoolean(cs_cache,table,field)

    //============================================================================================================
    function SetTableString takes string table, string field, string val returns nothing
        if (val=="") or (val==null) then
            call FlushStoredString(cs_cache,table,field)
        else
            call StoreString(cs_cache,table,field,val)
        endif
    endfunction
    function GetTableString takes string table, string field returns string
        return GetStoredString(cs_cache,table,field)
    endfunction
    //! define GetTableString(table,field) GetStoredString(cs_cache,table,field)

    //============================================================================================================
    // You may ask why am I using thousands of functions instead of multi-use return bug exploiters? Well,
    // these make the thing much easier to read (in my opinion) and it is also better in performance since we
    // have less function calls (H2U(GetTableObject("table","unit"))) would be worse than GetTableUnit that is
    // quite direct.
    //
    function SetTableObject takes string table, string field, handle val returns nothing
        if (val==null) then
            call FlushStoredInteger(cs_cache,table,field)
        else
            call StoreInteger(cs_cache,table,field,CS_H2I(val))
        endif
    endfunction
    function GetTableObject takes string table, string field returns handle
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableWidget takes string table, string field returns widget
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableRect takes string table, string field returns rect
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableRegion takes string table, string field returns region
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableTimerDialog takes string table, string field returns timerdialog
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableUnit takes string table, string field returns unit
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableItem takes string table, string field returns item
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableEffect takes string table, string field returns effect
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableDestructable takes string table, string field returns destructable
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableTrigger takes string table, string field returns trigger
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableTimer takes string table, string field returns timer
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableGroup takes string table, string field returns group
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableTriggerAction takes string table, string field returns triggeraction
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableLightning takes string table, string field returns lightning
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableImage takes string table, string field returns image
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableUbersplat takes string table, string field returns ubersplat
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableSound takes string table, string field returns sound
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction
    function GetTableLoc takes string table, string field returns location
        return GetStoredInteger(cs_cache,table,field)
        return null
    endfunction


    //============================================================================================================
    // Returns true if the fiel contains a value different from 0, false,  null, or "" (depending on the type)
    // it is worthless to use this with boolean, since it would be the same as reading the boolean value
    //
    function HaveSetField takes string table, string field, integer fieldType returns boolean
        if (fieldType == bj_GAMECACHE_BOOLEAN) then
            return HaveStoredBoolean(cs_cache,table,field)
        elseif (fieldType == bj_GAMECACHE_INTEGER) then
            return HaveStoredInteger(cs_cache,table,field)
        elseif (fieldType == bj_GAMECACHE_REAL) then
            return HaveStoredReal(cs_cache,table,field)
        elseif (fieldType == bj_GAMECACHE_STRING) then
            return HaveStoredString(cs_cache,table,field)
        endif
     return false
    endfunction

    //============================================================================================================
    // Allows to copy a table to another one, but it needs a FieldData object to know which fields of which type
    // it is supposed to copy.
    //
    function CopyTable takes integer FieldData, string sourceTable, string destTable returns nothing
     local integer i=1
     local string k=I2S(FieldData)
     local string k2
     local string k3
     local integer n=GetStoredInteger(cs_cache,k,"N")
     local integer t
        loop
            exitwhen (i>n)
            set k2=I2S(i)
            set t=GetStoredInteger(cs_cache,k,k2)
            set k3=GetStoredString(cs_cache,k,k2)
            if (t==bj_GAMECACHE_BOOLEAN) then
                if (HaveStoredBoolean(cs_cache,sourceTable,k3)) then
                    call StoreBoolean(cs_cache,destTable,k3,GetStoredBoolean(cs_cache,sourceTable,k3))
                else
                    call FlushStoredBoolean(cs_cache,destTable,k3)
                endif
            elseif (t==bj_GAMECACHE_INTEGER) then
                if (HaveStoredInteger(cs_cache,sourceTable,k3)) then
                    call StoreInteger(cs_cache,destTable,k3,GetStoredInteger(cs_cache,sourceTable,k3))
                else
                    call FlushStoredInteger(cs_cache,destTable,k3)
                endif
            elseif (t==bj_GAMECACHE_REAL) then
                if (HaveStoredReal(cs_cache,sourceTable,k3)) then
                    call StoreReal(cs_cache,destTable,k3,GetStoredReal(cs_cache,sourceTable,k3))
                else
                    call FlushStoredReal(cs_cache,destTable,k3)
                endif
            elseif (t==bj_GAMECACHE_STRING) then
                if (HaveStoredString(cs_cache,sourceTable,k3)) then
                    call StoreString(cs_cache,destTable,k3,GetStoredString(cs_cache,sourceTable,k3))
                else
                    call FlushStoredString(cs_cache,destTable,k3)
                endif
            endif
            set i=i+1
        endloop


    endfunction

    //=============================================================================================
    // FieldData inherits from Table, was just designed to be used by CopyTable.
    //
    function FieldData_Create takes nothing returns integer
        return NewTableIndex()
    endfunction
    //! define FieldData_Create NewTableIndex


    //============================================================================================================
    // valueType uses the same integer variables from blizzard.j :
    // bj_GAMECACHE_BOOLEAN, bj_GAMECACHE_INTEGER, bj_GAMECACHE_REAL and bj_GAMECACHE_STRING
    //
    function FieldData_AddField takes integer fielddata, string field, integer valueType returns nothing
     local string k=I2S(fielddata)
     local integer n=GetStoredInteger(cs_cache,k,"N")+1
     local string k2=I2S(n)

        call StoreString(cs_cache,k,k2,field)
        call StoreInteger(cs_cache,k,k2,valueType)
        call StoreInteger(cs_cache,k,"N",n)

    endfunction

    //=============================================================================================
    // Destroys Field Data
    function FieldData_Destroy takes integer fielddata returns nothing
        call DestroyTable(I2S(fielddata))
    endfunction
    //! define FieldData_Destroy(fielddata) DestroyTable(I2S(fielddata))

    //=============================================================================================
    // Pools
    //
    // A better name for pools would be sets, but by the time I made them I couldn't think of that
    // name, besides the word set is already a JASS syntax word so it would have been problematic.
    //
    // Another naming failure is that values of a pool are called "items" but that conflicts with
    // the word item that points to wc3 items, Pools can only store integer values, but if you want
    // you can go and use the return bug on them.
    //

    function CreatePool takes nothing returns integer
     local integer i=NewArray(34,false)
        call SetArrayInt(i,0,0)
     return i
    endfunction

    function ClearPool takes integer poolid returns nothing
        call SetArrayInt(poolid,0,0) //[0:integer:n]
        call FlushStoredMission(cs_cache,I2S(-poolid))
    endfunction

    function DestroyPool takes integer poolid returns nothing
        call DestroyArray(poolid)
    endfunction
    //! define DestroyPool(p) DestroyArray(p)


    function PoolAddItem takes integer poolid, integer value returns nothing
     local integer n
     local string k=I2S(-poolid)
     local string vk="#"+I2S(value)
        if not HaveStoredInteger(cs_cache,k,vk) then
            set n=GetArrayInt(poolid,0)+1 //[0:integer:N] 
            call StoreInteger(cs_cache,k,vk,n)
            if (n>33) then
                call StoreInteger(cs_cache,k,I2S(n),value)
            else
                call SetArrayInt(poolid,n,value)
            endif
            call SetArrayInt(poolid,0,n) //[0:integer:N]
        endif
    endfunction



    function PoolRemoveItem takes integer poolid, integer value returns nothing
     local string k=I2S(-poolid)
     local string vk="#"+I2S(value)

     local integer p=GetStoredInteger(cs_cache,k,vk)
     local integer n

        if (p!=0) then
            set n=GetArrayInt(poolid,0) //[0:integer:N]
            call FlushStoredInteger( cs_cache, k, vk)
            
            if (n>p) then
            
                if (n>33) then
                    set vk=I2S(n)
                    set value=GetStoredInteger(cs_cache,k,vk)
                    call FlushStoredInteger(cs_cache,k,vk)
                else
                    set value=GetArrayInt(poolid,n)
                endif
                call StoreInteger(cs_cache,k,"#"+I2S(value),p)
                if (p>33) then
                    call StoreInteger(cs_cache,k,I2S(p),value)
                else
                    call SetArrayInt(poolid,p,value)
                endif
            elseif (p>33) then
                call FlushStoredInteger(cs_cache,k,I2S(p))
            endif
            call SetArrayInt( poolid,0,n - 1) //[0:integer:N]
        endif
    endfunction

    //===================================================================================
    function PoolGetItem takes integer poolid, integer itemn returns integer
        if (itemn>33) then
            return GetStoredInteger( cs_cache, I2S(-poolid), I2S(itemn))
        endif
     return GetArrayInt(poolid,itemn)
    endfunction

    //===================================================================================
    function CountItemsInPool takes integer poolid returns integer
     return GetArrayInt(poolid,0) //[0:integer:N]
    endfunction
    //! define CountItemsInPool(p) GetArrayInt(p,0)


    //===================================================================================
    // Removed : GetEnumPoolItem , ForPool and ForPool2 they are much worse than just
    // using CountItemsInPool and PoolGetItem to iterate the pool
    //

    //===================================================================================
    function GetFirstOfPool takes integer poolid returns integer
        return GetArrayInt(poolid,1) //[1 is just the first of the pool]
    endfunction
    //! define GetFirstOfPool(p) GetArrayInt(p,1)

    //===================================================================================
    function PoolPickRandomItem takes integer poolid returns integer
     local integer p=GetRandomInt(  1, GetArrayInt(poolid,0) )
        if (p>33) then
            return GetStoredInteger( cs_cache, I2S(-poolid), I2S(p))
        endif
     return GetArrayInt(poolid,p)
    endfunction

    //===================================================================================
    function GetItemPositionInPool takes integer poolid, integer it returns integer
        return GetStoredInteger( cs_cache, I2S(-poolid), "#"+I2S(it))
    endfunction
    //! define GetItemPositionInPool(p,i) GetStoredInteger( cs_cache, I2S(- (p) ), "#"+I2S(i))

    //===================================================================================
    function IsItemInPool takes integer poolid, integer it returns boolean
        return(HaveStoredInteger( cs_cache, I2S(-poolid), "#"+I2S(it)) )
    endfunction
    //! define IsItemInPool(p,i) HaveStoredInteger( cs_cache, I2S(- (p) ), "#"+I2S(i))

    //===================================================================================
    // This had to be optimized for speed, if it was just a loop using the above functions 
    // that would have been too slow to be worth keeping. That's a bad thing about JASS
    // it is such an slow language that code reusability always has the cost of speed
    //
    function PoolAddPool takes integer sourcepoolid, integer destpoolid returns nothing
     local integer a=1
     local integer n=GetArrayInt( sourcepoolid,0) //[0:integer:N]
     local integer dn=GetArrayInt( destpoolid,0) //[0:integer:N]
     local string sk=I2S(-sourcepoolid)

     local string k=I2S(-destpoolid)
     local integer v
     local string vk

        loop
            exitwhen (a>n)
            if (a>33) then
                set v=GetStoredInteger(cs_cache,sk,I2S(a))
            else
                set v=GetArrayInt(sourcepoolid,a)
            endif
            set vk="#"+I2S(v)
            if not HaveStoredInteger(cs_cache,k,vk) then
                set dn=dn+1
                call StoreInteger(cs_cache,k,vk,dn)
                if (dn>33) then
                    call StoreInteger(cs_cache,k,I2S(dn),v)
                else
                    call SetArrayInt(destpoolid,dn,v)
                endif
            endif
            set a=a+1
        endloop
        call SetArrayInt(destpoolid,0,dn) //[0:integer:N]
    endfunction

    //=============================================================================================
    // Oh darn, After making PoolAddPool I don't feel like writting this one
    // All right I am at least make the get code
    //
    function PoolRemovePool takes integer sourcepoolid, integer destpoolid returns nothing
     local integer a=1
     local integer n=GetArrayInt( sourcepoolid,0) //[0:integer:N]
     local integer v
     local string sk=I2S(-sourcepoolid)
        loop
            exitwhen a>n
            if (a>33) then
                set v=GetStoredInteger(cs_cache,sk,I2S(a) )
            else
                set v=GetArrayInt(sourcepoolid,a)
            endif
            call PoolRemoveItem( destpoolid, v)
            set a=a+1
        endloop
    endfunction

    //===================================================================================
    // Adds a tokenized string to a pool,
    //  Example: PoolAddS(udg_p, "1;2;3;4") will add to the udg_p pool : 1,2,3 and 4
    //
    function PoolAddS takes integer poolid, string s returns nothing
     local integer i=0
     local integer st
     local string c
        set s=s+";"
        set st=0
        loop
            set c=SubString(s, i, i+1)
            exitwhen (c == "") or (c == null)
            if (c == ";") then
                call PoolAddItem( poolid, S2I(SubString(s, st, i)) )
                set st=i+1
            endif
            set i=i+1
        endloop
    endfunction

    //===================================================================================
    // Converts a tokenized string into a pool,
    //  Example: S2Pool( "1;2;3;4") will return a pool that has 1,2,3 and 4 inside
    //
    function S2Pool takes string s returns integer
     local integer spool= CreatePool()
        call PoolAddS(spool,s)
     return spool
    endfunction

    //===================================================================================
    // Does the opposite of S2Pool, debugging is a good use for this function.
    //
    function Pool2S takes integer P returns string
     local integer N=CountItemsInPool(P)
     local integer i
     local string s
        if (N>=1) then
            set s=I2S(PoolGetItem(P,1) )
            set i=2
        else
            return ""
        endif
        loop
            exitwhen (i>N)
            set s=s+";"+I2S(PoolGetItem(P,i))
            set i=i+1
        endloop
    return s
    endfunction

    //=============================================================================================================
    // Fixes a lame bug by blizzard related to the custom script section (The condition of the if statement might
    // actually be true.
    //
    function Pool_Percent takes nothing returns string
       if ("%"=="") then
           return "%%"
       endif
     return "%"
    endfunction

    function Pool_SetupCharMap takes nothing returns nothing
     local string cm=".................................!.#$"+Pool_Percent()+"&'()*+,-./0123456789:;<=>.@ABCDEFGHIJKLMNOPQRSTUVWXYZ[.]^_`abcdefghijklmnopqrstuvwxyz{|}~................................................................................................................................."
     local integer i=0
     local string c
        if HaveStoredInteger(cs_cache,"charmap_upper","A") then
            return
        endif
        loop
            set c=SubString(cm,i,i+1)
            exitwhen (c==null) or (c=="")
            if (c!=".") then
                if c==StringCase(c,true) then
                    call StoreInteger(cs_cache,"charmap_upper",c,i)
                else
                    call StoreInteger(cs_cache,"charmap_lower",c,i)
                endif
                
            endif
            set i=i+1
        endloop

    endfunction


    function Pool_Rawcode2Int takes string s returns integer
     local string c
     local integer i=0
     local integer r=0
        loop
            exitwhen i>3
            set c=SubString(s,i,i+1)
            set r=r*256
            if c==StringCase(c,true) then
                set r=r+GetStoredInteger(cs_cache,"charmap_upper",c)
            else
                set r=r+GetStoredInteger(cs_cache,"charmap_lower",c)
            endif
            
            set i=i+1
        endloop
     return r
    endfunction

    function PoolAddRawcodes_thread takes nothing returns nothing
    //Threaded because I don't want it to halt execution for no reason
    //
     local string s=bj_lastPlayedMusic
     local integer poolid=bj_groupEnumTypeId
     local string c
     local integer i=0
     local integer st=0
        set s=s+";"
        loop
            set c=SubString(s, i, i+1)
            exitwhen (c == "") or (c == null)
            if c == ";" then
                call PoolAddItem(poolid, Pool_Rawcode2Int(SubString(s,st,i) ))
                set st=i+1
            endif
            set i=i+1
        endloop

    endfunction

    //=====================================================================================================================
    // Adds a string of tokenized rawcodes to a pool
    //  Example: PoolAddRawcodes(udg_p,"A000;A001")  will add 'A000' and 'A001' to the pool
    //
    // (Saves some lines, but is not as good efficiency wise)
    //
    function PoolAddRawcodes takes integer poolid, string s returns nothing
     local string b=bj_lastPlayedMusic
        set bj_groupEnumTypeId=poolid
        set bj_lastPlayedMusic=s
        call ExecuteFunc("PoolAddRawcodes_thread")
        set bj_lastPlayedMusic=b
    endfunction

    //===================================================================================================================
    // Converts a tokenized string of rawcodes into a pool,
    //  Example: Rawcodes2Pool( "A000;A001;AHbz;S000") will return a pool that has 'A000,'A001','AHbx' and 'S000' inside
    //
    // (Saves some lines, but is not as good efficiency wise)
    //
    function Rawcodes2Pool takes string s returns integer
     local integer spool= CreatePool()
        call PoolAddRawcodes(spool,s)
     return spool
    endfunction

    //===================================================================================================================
    // A subproduct of the Pool's Rawcode support is that we can easily have this function so I am including it even if
    // it has nothing to do with data storage.
    //
    // takes "Aloc" and converts it into 'Aloc'
    // it is different to the Pool_Rawcode2Int function in that it is safe to use it when it is the first CSCache
    // function ever used. But it is a little slower (wc3mapoptimizer should make it as fast though)
    //
    function CS_Rawcode2Int takes string s returns integer
     local string c
     local integer i=0
     local integer r=0
        loop
            exitwhen i>3
            set c=SubString(s,i,i+1)
            set r=r*256
            if c==StringCase(c,true) then
                set r=r+GetStoredInteger(cs_cache,"charmap_upper",c)
            else
                set r=r+GetStoredInteger(cs_cache,"charmap_lower",c)
            endif
            
            set i=i+1
        endloop
     return r
    endfunction

    function CSCache takes nothing returns gamecache
    return cs_cache //Left for compat.
    endfunction

endlibrary

//**************************************************************************************************
//* 
//* Independant Summons (Code + config)
//* ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
//* You just need to copy this trigger, notice that these functions do nothing without the other
//* part which has the header functions and you'll also need to call them.
//*
//**************************************************************************************************


//==================================================================================================
// Independant Summons Configuration:
//
constant function IndieSummon_maxdelay takes nothing returns real
    return 2.5 //* The max delay betwen orders issued to the summon
endfunction

constant function IndieSummon_mindelay takes nothing returns real
    return 1.00 //* The min delay betwen orders issued to the summon
endfunction

constant function IndieSummon_maxdistance takes nothing returns real
    return 1000.0 //* If the distance betwen the summon and the master is greater than this value,
                  //  The summon will move to the position of the master instead of attack move
endfunction

constant function IndieSummon_cometomaxdist takes nothing returns real
    return 500.0 //* Max distance for issued orders to approach the master
endfunction

constant function IndieSummon_cometomindist takes nothing returns real
    return 100.0 //* Min distance for issued orders to approach the master
endfunction

//==================================================================================================
function IndieSummon_Order takes unit summon, unit master returns nothing
 local integer o=GetUnitCurrentOrder(summon)
 local real tx=GetUnitX(master)
 local real ty=GetUnitY(master)
 local real angle
 local real dist

    set dist=Pow(tx-GetUnitX(summon),2) + Pow(ty-GetUnitY(summon),2)
    if (dist > (IndieSummon_maxdistance()*IndieSummon_maxdistance()) )  and (o == 0 or o == OrderId("attack") or o == OrderId("move") or o == OrderId("stop") or o==851971) then
        call IssuePointOrder(summon, "move", tx,ty) 
    elseif dist >= (IndieSummon_cometomindist()*IndieSummon_cometomindist()) and (o == 0 or o == 851971) then
        set angle = GetRandomReal( GetUnitFacing(master)-80, GetUnitFacing(master)+80)
        if (ModuloInteger(GetUnitPointValue(summon),2)==0) then
            set angle=angle * bj_DEGTORAD
        else
            set angle=- angle * bj_DEGTORAD
        endif

        set dist = GetRandomReal(IndieSummon_cometomindist(), IndieSummon_cometomaxdist() )
        set tx=tx+dist*Cos(angle)
        set ty=ty+dist*Sin(angle)
        if not IssuePointOrder(summon, "attack", tx, ty ) then
            call IssuePointOrder(summon, "move", tx, ty )
        endif
    endif
 set summon=null
 set master=null
endfunction

function IndieSummon_AntiSmart_Timer takes nothing returns nothing
 local timer t=GetExpiredTimer()
 local string k=GetAttachmentTable(t)
 local unit s=GetTableUnit(k,"summon")
    if (GetUnitCurrentOrder(s)!=851971) then
        call ClearTable(k)
        call DestroyTimer(t)
    else
        call IndieSummon_Order( s, GetTableUnit("[IndieSummons]",GetAttachmentTable(s)) )
        call TimerStart(t,0.1,false,function IndieSummon_AntiSmart_Timer)
    endif
 set t=null
endfunction


function IndieSummon_AntiSmart takes nothing returns nothing
 local timer t

    if (GetIssuedOrderId() == 851971) then
        set t=CreateTimer()
        call AttachObject(t,"summon",GetTriggerUnit())
        call TimerStart(t,0,false,function IndieSummon_AntiSmart_Timer)
        set t=null
    endif

endfunction

function IndieSummon_loop takes nothing returns nothing
// Executed in another thread
 local unit summon=bj_ghoul[0]  
 local string k=GetAttachmentTable(summon)
 local unit master
 local trigger smart=CreateTrigger()
 local integer n=0
 local triggeraction ac=TriggerAddAction( smart, function IndieSummon_AntiSmart)

    call TriggerRegisterUnitEvent( smart, summon, EVENT_UNIT_ISSUED_TARGET_ORDER )
    call TriggerRegisterUnitEvent( smart, summon, EVENT_UNIT_ISSUED_POINT_ORDER )
    loop
        exitwhen (GetWidgetLife(summon)<=0)
        set master=GetTableUnit("[IndieSummons]",k)
        if (master==null) then
            exitwhen true
        else
            call IndieSummon_Order( summon, master)
            call PolledWait( GetRandomReal( IndieSummon_mindelay(), IndieSummon_maxdelay() ))
        endif
    endloop

    call SetTableObject("[IndieSummons]",k,null)
    call TriggerRemoveAction(smart,ac)
    call DestroyTrigger(smart)

 set ac=null
 set summon=null
 set master=null
 set smart=null
endfunction


//===========================================================================
function InitTrig_IndieSummon_Code takes nothing returns nothing
endfunction