library StunUnit initializer Init
{
    private timer   periodicTimer = CreateTimer()    // Can be replaced with main map timer

    private unit    unitsStack[]
    private effect  effectsStack[]  // Stun effect storage
    private float   timeRemaining[] // Time of stun left
    private int     stackCounter = 0

    #define private TICK_PERIOD  = 0.05
    #define private STACK_LIMIT  = 8190
    #define private STUN_EFFECT  = "Abilities\\Spells\\Human\\Thunderclap\\ThunderclapTarget.mdl"
    #define private ORDERID_STOP = 0xD0004


    // Looking for id of specified unit in stack
    private int StackSearch(unit givenUnit) {
        int i = -1
        while(i++ < stackCounter) {
            if (givenUnit == unitsStack[i]) {
                return i
            }
        }
        return -1
    }

    // Add unit to stack with overflow check
    private void StackPush(unit givenUnit, float duration) {
        if(stackCounter < STACK_LIMIT) {
            unitsStack   [stackCounter] = givenUnit
            effectsStack [stackCounter] = AddSpecialEffectTarget(STUN_EFFECT, givenUnit, "overhead")
            timeRemaining[stackCounter] = duration
            stackCounter++
        } else {
            BJDebugMsg("Stunned units stack overflow!")
        }
    }

    // Remove unit from stack
    private void StackPop(int id) {

        DestroyEffect(effectsStack[id])

        stackCounter--
        unitsStack   [id] = unitsStack   [stackCounter]
        effectsStack [id] = effectsStack [stackCounter]
        timeRemaining[id] = timeRemaining[stackCounter]

        unitsStack   [stackCounter] = null
        effectsStack [stackCounter] = null
        timeRemaining[stackCounter] = 0.0
    }

    void StunUnit(unit givenUnit, float duration) {

        int stackedUnitId = StackSearch(givenUnit)

        if (stackedUnitId == -1) {
            StackPush(givenUnit, duration)
        } elseif (timeRemaining[stackedUnitId] < duration) {		// <=!!
            timeRemaining[stackedUnitId] = duration
        }
    }

    private void TimerCallback() {

        int i = -1

        while(i++ < stackCounter) {

            timeRemaining[i] -= TICK_PERIOD
            IssueImmediateOrderById(unitsStack[i], ORDERID_STOP)

            if (timeRemaining[i] <= 0.0) {
                StackPop(i)
            }
        }
    }

    private void Init() {
        TimerStart(periodicTimer, TICK_PERIOD, true, function TimerCallback)
    }
}

library StunStack initializer Init
{
    #define private STACK_LIMIT = 8190
    #define private TICK_PERIOD = 0.05
    #define private STUN_EFFECT = "Abilities\\Spells\\Human\\Thunderclap\\ThunderclapTarget.mdl"

            timer   globalTimer = CreateTimer() // Can be replaced with main map timer

    private unit    unitsStack[]
    private effect  effectsStack[]              // Stun effect storage
    private float    timeRemaining[]             // Time of stun left
    private int     stackCounter = 0


    // Looking for id of specified unit in stack
    private int StackSearch(unit givenUnit) {
        int i = -1
        while(i++ < stackCounter) {
            if (givenUnit == unitsStack[i]) {
                return i
            }
        }
        return -1
    }

    // Add unit to stack with overflow check
    private void StackIncrement(unit givenUnit, float duration) {
        if(stackCounter < STACK_LIMIT) {
            PauseUnit(givenUnit, true)
            unitsStack   [stackCounter] = givenUnit
            effectsStack [stackCounter] = AddSpecialEffectTarget(STUN_EFFECT, givenUnit, "overhead")
            timeRemaining[stackCounter] = duration
            stackCounter++
        } else {
            BJDebugMsg("Stunned units stack overflow!")
        }
    }

    // Remove unit from stack
    private void StackDecrement(unit givenUnit, int id) {
        DestroyEffect(effectsStack[id])
        PauseUnit(givenUnit, false)
        stackCounter--
        unitsStack   [id] = unitsStack   [stackCounter]
        effectsStack [id] = effectsStack [stackCounter]
        timeRemaining[id] = timeRemaining[stackCounter]
        unitsStack   [stackCounter] = null
        effectsStack [stackCounter] = null
        timeRemaining[stackCounter] = 0.0
    }

    void StunUnit(unit givenUnit, float duration) {
        int stackedUnitId = StackSearch(givenUnit)
        if (stackedUnitId == -1) {
            StackIncrement(givenUnit, duration)
        } elseif (timeRemaining[stackedUnitId] < duration) {
            timeRemaining[stackedUnitId] = duration
        }
    }

    private void TimerCallback() {
        int i = -1
        while(i++ < stackCounter) {

            timeRemaining[i] -= TICK_PERIOD

            if (timeRemaining[i] <= 0.0) {
                StackDecrement(unitsStack[i], i)
            }
        }
    }

    private void Init() {
        TimerStart(globalTimer, TICK_PERIOD, true, function TimerCallback)
    }
}

    constant pathingtype        PATHING_TYPE_ANY                = ConvertPathingType(0)
    constant pathingtype        PATHING_TYPE_WALKABILITY        = ConvertPathingType(1)
    constant pathingtype        PATHING_TYPE_FLYABILITY         = ConvertPathingType(2)
    constant pathingtype        PATHING_TYPE_BUILDABILITY       = ConvertPathingType(3)
    constant pathingtype        PATHING_TYPE_PEONHARVESTPATHING = ConvertPathingType(4)
    constant pathingtype        PATHING_TYPE_BLIGHTPATHING      = ConvertPathingType(5)
    constant pathingtype        PATHING_TYPE_FLOATABILITY       = ConvertPathingType(6)
    constant pathingtype        PATHING_TYPE_AMPHIBIOUSPATHING  = ConvertPathingType(7)

native IsTerrainPathable        takes real x, real y, pathingtype t returns boolean
native SetTerrainPathable       takes real x, real y, pathingtype t, boolean flag returns nothing