Circular movement

local Data d = GetTimerData( t )

local real x = GetUnitX( d.caster )
local real y = GetUnitY( d.caster )

local real tx
local real ty

set d.angle = d.angle + VELOCITY/ (2*bj_PI*d.dist)

set tx = x + d.dist * Cos( d.angle )
set ty = y + d.dist * Sin( d.angle )

scope IntSummon initializer Init
    globals
        private constant integer SUMMON_ID = 'hphx'
        private constant real VELOCITY = 600.
        private constant real CICLE_TIMER = 0.02
        private constant real RANGE = 800
    endglobals
//===========================================================================
    private struct aSummon
        unit caster
        unit summon
        timer t

        real face
        real summonX
        real summonY
        real newX
        real newY
        real newface

        
        static method summonLoop takes nothing returns nothing
            local aSummon data = aSummon(GetTimerData(GetExpiredTimer())) 
            
            //if the unit has no order, than it is stoped and we force it to make 
            //circles
            //if GetCurrentOrder == DoNothing then
                //update the current position of the summon
                set data.face = GetUnitFacing(data.summon)
                set data.summonX = data.summonX + ( (VELOCITY * CICLE_TIMER) * Cos(data.face * bj_DEGTORAD) )
                set data.summonY = data.summonY + ( (VELOCITY * CICLE_TIMER) * Sin(data.face * bj_DEGTORAD) )
                
                //move the bird =P
                call SetUnitX(data.summon, data.summonX)
                call SetUnitY(data.summon, data.summonY)

                //Choose new position for summon to walk next time
                set data.newX = GetUnitX(data.caster) + ( ( GetRandomReal(0, RANGE) * CICLE_TIMER) * Cos(  360 * bj_DEGTORAD) )
                set data.newY = GetUnitY(data.caster) + ( ( GetRandomReal(0, RANGE) * CICLE_TIMER) * Sin(  360 * bj_DEGTORAD) )
                set data.newface = bj_RADTODEG * Atan2(data.newY - GetUnitY(data.summon), data.newX - GetUnitX(data.summon))
                call SetUnitFacing(data.summon, data.newface)
            //elseif GetCurrentOrder == MoveToSomePoint
                //here I make the unit move to that point, but making semi-circles
            //elseif GetCurrentOrder == Attack
                //here I make the unit move to that point, but making semi-circles
                //when the unit reaches the target we attack it
                //after the attack we repeat last steps
            //end
        endmethod
        
        static method create takes unit c, unit s returns aSummon
            local aSummon data = aSummon.allocate()
            
            //setting members
            set data.caster = c
            set data.summon = s
            set data.face = GetUnitFacing(c)
            set data.summonX = GetUnitX(s)
            set data.summonY = GetUnitY(s)
            
            //the movement timer
            set data.t = NewTimer()
            call SetTimerData(data.t, integer(data))
            call TimerStart(data.t, CICLE_TIMER, true, function aSummon.summonLoop)
            
            return data
        endmethod
        
        method onDestroy takes nothing returns nothing
            call ReleaseTimer(.t)
        endmethod
    endstruct
//===========================================================================
    private function Conditions takes nothing returns boolean
        local aSummon data
        
        if GetUnitTypeId(GetSummonedUnit()) == SUMMON_ID then
            set data = aSummon.create(GetSummoningUnit(), GetSummonedUnit())
        endif
        
        return false
    endfunction
//===========================================================================
    private function Init takes nothing returns nothing
        //when the Unit is summoned
        local trigger IntSummonTrg = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ(IntSummonTrg, EVENT_PLAYER_UNIT_SUMMON)
        call TriggerAddCondition(IntSummonTrg, Condition(function Conditions))
    endfunction
endscope