[Help] TimerFuncs

    globals
        private timer T=CreateTimer()
        private timer ET=CreateTimer()
        private trigger TR=CreateTrigger()
        
        private timerfunc CURR=0
    endglobals

library TimerObjects initializer Init
//******************************
//* Timer Objects 0.3
//* ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
//*    By StealthOfKing
//*
//* Requires vJass.
//*
//* TimerObjects is a small library that allows you to use "timed structs". A timerobject is little more that a node within a
//* linked list, with methods to start and stop it. By using a linked list approach it is easy to stop and start timerobjects
//* (add and remove them from the list). Also included is a basic system to let you use delayed functions.
//*
//* Credit to Vexorian for original idea from TimeLib and vJass!
//*
//* To use:
//*     timerobject             - The basic timed struct.
//*     DelayedFunction         - The function interface to use with DelayedCall.
//*
//*     function DelayedCall    - Executes any function that follows the DelayedFunction interface after a specified delay.
//*
globals
//* Configuration
//* ¯¯¯¯¯¯¯¯¯¯¯¯¯
//* Enables a debug mode for timerobjects, informing you of every object started, stopped or expired, and the content of the
//* list at that time.
    debug constant boolean TIMER_OBJECTS_DEBUG = true
//*
//**********************************************************************************************************************************
endglobals

// Simple function interface.
function interface DelayedFunction takes integer tag returns nothing

// function DelayedCall start's a timed function. Returns a delayedfuncstr, which lets you store the DelayedFunction allowing
// you to stop it (and restart it).
//   Takes:
//      DelayedFunction func    - The function you want to call after the delay (any function that follows the DelayedFunction function interface).
//      integer tag             - Any integer value you wish, allows you to pass data (perhaps a struct) to the DelayedFunction.
//      real delay              - The time you want to delay by, should be 0 or more.
function DelayedCall takes DelayedFunction func, integer tag, real delay returns delayedfuncstr
    local delayedfuncstr t = delayedfuncstr.create()
    set t.func = func
    set t.tag = tag
    call t.start(delay, false)
    return t
endfunction

// A very basic timerobject struct used to execute DelayedFunctions.
struct delayedfuncstr extends timerobject
    DelayedFunction func
    integer         tag

    method onExpire takes nothing returns nothing
        call .func.execute(.tag)    // Execute the DelayedFunction.
        call .destroy()             // DelayedFunctions execute only once then are destroyed.
    endmethod
endstruct

// Interface only used to give the onExpire method signature to timerobjects.
interface timerobjectinterface
    // Called when an object expires.
    method onExpire takes nothing returns nothing defaults nothing
endinterface

// Main struct.
struct timerobject extends timerobjectinterface
    real        timeout                     // The delay... it is easier to work with these objects by thinking of when they
                                            // will expire in relation to total elapsed time (so this will store delay +
                                            // elapsed game time).
    timerobject next        = 0             // List pointers. Default 0 means they point to nothing when created.
    timerobject prev        = 0

    boolean     periodic    = false

    static timer T          = CreateTimer() // Timer for running timerobjects.
    static timer ET         = CreateTimer() // Elapsed game time.
    static timerobject curr = 0             // The first object (next to expire) in the list.

    debug method debug takes string txt returns nothing
        debug local timerobject obj = timerobject.curr
        debug local string s = ""
        debug if not TIMER_OBJECTS_DEBUG then
            debug return
        debug endif
        debug loop
            debug exitwhen obj == 0
            debug set s = s + I2S(obj) + "@" + R2S(obj.timeout) + ", "
            debug set obj = obj.next
        debug endloop
        debug call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 999, txt + I2S(this) + "@" + R2S(.timeout) + ".")
        debug call DisplayTimedTextToPlayer(GetLocalPlayer(), 0, 0, 999, "Queued: " + s)
    debug endmethod

    // The main function that handles any timerobject expiring.
    static method onExpireHandler takes nothing returns nothing
        local timerobject expired = timerobject.curr

        set timerobject.curr = expired.next

        if expired.periodic then
        else
            if timerobject.curr != 0 then   // Starts the next timerobject to expire if there is any.
                if timerobject.curr.next == expired then    // Clear's the next object's pointers if it is the only remaining timerobject.
                    set timerobject.curr.next = 0
                endif
                set timerobject.curr.prev = 0
                call TimerStart(timerobject.T, timerobject.curr.timeout - TimerGetElapsed(timerobject.ET), false, function timerobject.onExpireHandler)
            endif

            set expired.next = 0    // Clear the pointers.
            set expired.prev = 0
        endif

        debug call expired.debug("Expired ")

        call expired.onExpire() // Woop!
    endmethod

    // Method start adds the object to the expiring list. Objects are added in order of shortest timeout to longest timeout.
    method start takes real timeout, boolean periodic returns nothing
        local timerobject obj = timerobject.curr

        debug if .next != 0 and .prev != 0 then
            debug call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, ".start(" + R2S(timeout) + ", " + b2s.evaluate(periodic) + ") called on active timerobject@" + I2S(this) + ".")
            debug return
        debug endif

        set .periodic = periodic

        // If the list is empty then start the object, otherwise find its place in the list, and add it. If the object added
        // is the next to expire, then start it.
        if obj == 0 then
            set .timeout = timeout + TimerGetElapsed(timerobject.ET)

            set .next = 0
            set .prev = 0

            set timerobject.curr = this
            call TimerStart(timerobject.T, timeout, false, function timerobject.onExpireHandler)
        else
            set timeout = timeout + TimerGetElapsed(timerobject.ET)
            set .timeout = timeout
            loop
                if timeout < obj.timeout then
                    set .next = obj
                    set .prev = obj.prev
                    set .next.prev = this
                    set .prev.next = this
                    exitwhen true
                elseif obj.next == 0 then
                    set .next = 0
                    set .prev = obj
                    set .prev.next = this
                    exitwhen true
                endif
                set obj = obj.next
            endloop
            if .next == timerobject.curr then   // Check if the object is the first to expire.
                set timerobject.curr = this
                call PauseTimer(timerobject.T)
                call TimerStart(timerobject.T, timeout - TimerGetElapsed(timerobject.ET), false, function timerobject.onExpireHandler)
            endif
        endif
        debug call .debug("Started ")
    endmethod

    // Method stop removes an object from the expiring list, stopping it's wait/execution.
    method stop takes nothing returns nothing
        debug if .next == 0 and .prev == 0 then
            debug call DisplayTextToPlayer(GetLocalPlayer(), 0, 0, ".stop() called on inactive timerobject@" + I2S(this) + ".")
            debug return
        debug endif

        // If this is the next timerobject scheduled to expire stop the timer, start it for the next object (if it is not 0).
        if this == timerobject.curr then
            call PauseTimer(timerobject.T)

            set timerobject.curr = .next

            if timerobject.curr != 0 then
                set timerobject.curr.prev = 0
                call TimerStart(timerobject.T, timerobject.curr.timeout - TimerGetElapsed(timerobject.ET), false, function timerobject.onExpireHandler)
            endif
        elseif .next != 0 then      // Timerobject must be somewhere in the list, but not at the end (or .next would have a value).
            set .prev.next = .next  // Remove object from list and repair pointers.
            set .next.prev = .prev
        else                        // Last timerobject in list.
            set .prev.next = 0      // Clear the previous object's pointer.
        endif

        set .next = 0
        set .prev = 0

        debug call .debug("Stopped ")
    endmethod

    // Stop any objects that are destroyed.
    method onDestroy takes nothing returns nothing
        if .next != 0 or .prev != 0 then
            call .stop()
        endif
    endmethod
endstruct

// Init only needs to start the elapsed game time timer.
public function Init takes nothing returns nothing
    call TimerStart(timerobject.ET, 999999, false, null)
endfunction

// Debug related.
debug constant function b2s takes boolean b returns string
    debug if b then
        debug return "true"
    debug else
        debug return "false"
    debug endif
debug endfunction
endlibrary