library UF
    {
        location GL = Location(0., 0.)
        
        real AngleBetweenCoords (real x1, real x2, real y1, real y2)
        {
            return bj_RADTODEG * Atan2(y2-y1, x2-x1)
        }
        
        real GetPointZ (float x, float y)
        {
            MoveLocation(GL , x , y)
            return GetLocationZ(GL)
        }
        
        function GetUnitZin takes unit u,real X,real Y returns real
            call MoveLocation(GL , X , Y)
            return GetUnitFlyHeight(u) + GetLocationZ(GL)
        endfunction

        function SetUnitZin takes unit u,real z,real X,real Y returns nothing
            call MoveLocation(GL , X , Y)
            call SetUnitFlyHeight(u , z - GetLocationZ(GL) , 0)
        endfunction

        function GetUnitZ takes unit u returns real
            call MoveLocation(GL , GetUnitX(u) , GetUnitY(u))
            return GetUnitFlyHeight(u) + GetLocationZ(GL)
        endfunction

        function SetUnitZ takes unit u,real z returns nothing
            call MoveLocation(GL , GetUnitX(u) , GetUnitY(u))
            call SetUnitFlyHeight(u , z - GetLocationZ(GL) , 0)
        endfunction
    }

    struct vector
    {
        float x
        float y
        float z
        
        static thistype Velocity (vector one, vector two, float speed)
        {
            thistype vel = thistype.create()
            float length = SquareRoot((two.x-one.x)*(two.x-one.x)+(two.y-one.y)*(two.y-one.y)+(two.z-one.z)*(two.z-one.z))
            vel.x = ((two.x-one.x)/length)*speed
            vel.y = ((two.y-one.y)/length)*speed
            vel.z = ((two.z-one.z)/length)*speed
            return vel
        }
        
        static float GetDist (vector one, vector two)
        {
            return SquareRoot((two.x-one.x)*(two.x-one.x)+(two.y-one.y)*(two.y-one.y)+(two.z-one.z)*(two.z-one.z))
        }
        
        static vector New (float x, float y, float z)
        {
            vector vec = vector.create()
            vec.x = x
            vec.y = y
            vec.z = z
            return vec
        }
        
        static void SumVec (vector old, vector sum)
        {
            old.x+=sum.x
            old.y+=sum.y
            old.z+=sum.z
        }
    }

 
    // Steck data
        int total_pj = 0
        projectile array the_pj
    // Constants
        cn float projectile_period = 0.04
    
    struct projectile
    {
        vector vel
        vector pos
        unit main
        float speed
        effect model
        int death
        bool kill
        float max_distance
        float now_distance
        
        static thistype create (unit caster, float x, float y, float z, float dmg, float speed)
        {
            thistype pj = thistype.allocate()
            pj.pos = vector.New(GetUnitX(caster), GetUnitY(caster), GetUnitZ(caster)+25.)
            vector t_pos = vector.New(x, y, z)
            pj.max_distance = vector.GetDist(pj.pos, t_pos)
            pj.now_distance = 0.
            pj.speed = speed
            pj.vel = vector.Velocity(pj.pos, t_pos, speed)
            pj.main = CreateUnit(GetOwningPlayer(caster), 'h000', pj.pos.x, pj.pos.y, AngleBetweenCoords(pj.pos.x, x, pj.pos.y, y))
            SetUnitZ(pj.main, pj.pos.z)
            the_pj[total_pj] = pj
            total_pj++
            pj.kill = FALSE
            return pj
        }
        
        void setModel (string eff, int death_dest)
        {
            .model = AddSpecialEffectTarget(eff, .main, "origin")
            .death = death_dest
        }
        
        void setPosition ()
        {
            vector.SumVec(.pos, .vel)
            if  (.pos.x>GetRectMinX(bj_mapInitialPlayableArea))&&\
            (.pos.x<GetRectMaxY(bj_mapInitialPlayableArea))&&\
            (.pos.y>GetRectMinY(bj_mapInitialPlayableArea))&&\
            (.pos.y<GetRectMaxY(bj_mapInitialPlayableArea))&&\
            .now_distance<=.max_distance&&\
            GetUnitFlyHeight(.main)>2.
            {
                .now_distance+=.speed
                SetUnitX(.main, .pos.x)
                SetUnitY(.main, .pos.y)
                SetUnitZ(.main, .pos.z)
            else
                .kill = TRUE
            }
        }
        
        void onDestroy ()
        {
        
            destructable d = CreateDestructableZ(death, .pos.x, .pos.y, .pos.z, 0., 1., 1)
            KillDestructable(d)
            d = null
            RemoveUnit(.main)
            DestroyEffect(.model)
            .main  = null
            .model = null
        }
    }
    
    void UpdateProjectile ()
    {
        int i = 0
        whilenot (i == total_pj)
        {
            if the_pj[i] != 0
            {
                if not the_pj[i].kill
                {
                    the_pj[i].setPosition()
                else
                    projectile.destroy(the_pj[i])
                    the_pj[i] = 0
                }
            }
            i++
        }
    }
    
    callback onInit ()
    {
        timer t = CreateTimer()
        TimerStart(t, projectile_period, TRUE, func UpdateProjectile)
        t = null
    }

    library cast initializer I requires UF
    {
        
        private void Cast ()
        {
            /////////////////////////////////
            // Locals
            float x = GetSpellTargetX()
            float y = GetSpellTargetY()
            float z = 0.
            unit c = GetTriggerUnit()
            unit t = GetSpellTargetUnit()
            float speed = 0.
            float dmg = 0.
            string model = null
            int death_dest = 0
            /////////////////////////////////
            // Get target Z
            if t == null
            {
                z = GetPointZ(x, y)
            else
                z = GetUnitZ(t)
                x = GetUnitX(t)
                y = GetUnitY(t)
            }
            /////////////////////////////////
            // Fireball
            if GetSpellAbilityId() == 'A000'
            {
                speed = 800.
                dmg = 100.
                //model = "Abilities\\Weapons\\Mortar\\MortarMissile.mdl"
                death_dest = 'B000'
            }
            ////////////////////////////////
            // Creating projectile
            projectile pj = projectile.create(c, x, y, z, dmg, speed*projectile_period)
            pj.setModel(model, death_dest)
        }
        
        private void I ()
        {
            trigger Trg = CreateTrigger()
            TriggerRegisterPlayerUnitEvent(Trg, Player(0), EVENT_PLAYER_UNIT_SPELL_EFFECT, null)
            TriggerAddAction(Trg, func Cast)
            Trg = null
        }
    }