1. Updated Resource Submission Rules: All model & skin resource submissions must now include an in-game screenshot. This is to help speed up the moderation process and to show how the model and/or texture looks like from the in-game camera.
    Dismiss Notice
  2. DID YOU KNOW - That you can unlock new rank icons by posting on the forums or winning contests? Click here to customize your rank or read our User Rank Policy to see a list of ranks that you can unlock. Have you won a contest and still havn't received your rank award? Then please contact the administration.
    Dismiss Notice
  3. We have recently started the 16th edition of the Mini Mapping Contest. The theme is mini RPG. Do check it out and have fun.
    Dismiss Notice
  4. Choose your ride to damnation in the 5th Special Effect Contest Poll.
    Dismiss Notice
  5. The winners of the 13th Techtree Contest have been announced!
    Dismiss Notice
  6. Vote for the best entries in the 13th Music Contest Poll.
    Dismiss Notice
  7. Check out the Staff job openings thread.
    Dismiss Notice
Dismiss Notice
60,000 passwords have been reset on July 8, 2019. If you cannot login, read this.

[vJASS] Missile

Discussion in 'JASS Resources' started by BPower, May 4, 2015.

  1. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    Missile

    A library made to handle, optimize and ease projectile creation in your map.




    library Missile

    Read and modify the configuration block within the library very carefully, otherwise it's not garantueed that
    Missile is working properly. It should be mentioned that MissileRecycler is the optimal dummy recycler for Missile.
    Copy 'n' paste the following code into your map:
    Code (vJASS):
    library Missile /* version 2.5.1
    *************************************************************************************
    *
    *   Creating custom projectiles in Warcraft III.
    *  
    *   Major goal:
    *       No unessary external requirements.
    *       Implements code optional.
    *  
    *   Philosophy:
    *       I want that feature --> Compiler writes that code into your map script.
    *       I don't want that   --> Compiler ignores that code completly.
    *
    *   Important:
    *       Take yourself 2 minutes time to setup Missile correctly.
    *       Otherwise I can't guarantee, that Missile works the way you want.
    *       Once the setup is done, you can check out some examples and Missile will be easy
    *       to use for everyone. I promise it.
    *
    *       Do the setup at:
    *
    *           1.) Import instruction  
    *           2.) Global configuration
    *           3.) Function configuration      
    *  
    *   Credits to Dirac, emjlr3, AceHart, Bribe, Wietlol,
    *              Nestharus, Maghteridon96, Vexorian and Zwiebelchen.
    *
    *************************************************************************************
    *
    *   */
    requires /*
    *
    *       - Missile requires nothing.
    *
    *************************************************************************************
    *
    *   Optional requirements listed can reduce overall code generation,
    *   add safety mechanisms, decrease overhead and optimize handle management.  
    *   For a better overview I put them into blocks.
    *
    *   I recommend to use at least one per block in your map.
    *      
    *   a) For best debug results: ( Useful )
    *       */
    optional ErrorMessage    /* github.com/nestharus/JASS/tree/master/jass/Systems/ErrorMessage  
    *  
    *   b) Fatal error protection: ( Case: unit out moves of world bounds )  
    *           - WorldBounds is safer than BoundSentinel.
    *           - WorldBounds adds more overhead than BoundSentinel.
    *           - Using none of these two forces Missile to switch from SetUnitX/Y to the SetUnitPosition native.
    *       */
    optional WorldBounds     /* githubusercontent.com/nestharus/JASS/master/jass/Systems/WorldBounds/script.j
    *       */
    optional BoundSentinel   /* wc3c.net/showthread.php?t=102576
    *      
    *   c) Handle recycling: ( Performace gain, memory management )
    *           - uses MissileRecylcer > Dummy > xedummy.
    *       */
    optional MissileRecycler /* hiveworkshop.com/forums/jass-resources-412/system-missilerecycler-206086/
    *       */
    optional Dummy           /* github.com/nestharus/JASS/blob/master/jass/Systems/Dummy/Dummy.w3x
    *       */
    optional xedummy         /* wc3c.net/showthread.php?t=101150
    *
    *   d) Unit indexing: ( Avoid an onIndex event )
    *           - not required for Missile. Only if you use one already.
    *       */
    optional UnitIndexer     /* github.com/nestharus/JASS/tree/master/jass/Systems/Unit%20Indexer
    *
    ************************************************************************************
    *
    *   1. Import instruction
    *   ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
    *       • Copy Missile into to your map.
    *       • You need a dummy unit, using Vexorians "dummy.mdx".
    *         This unit must use the locust and crow form ability. ( Aloc & Amrf )
    *                   ¯¯¯¯
    *
    *   2. Global configuration  
    *   ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
    *       Seven constants to setup!
    */

        globals
       
            /**
            *   Missiles are moved periodically. An interval of 1./32. is recommended.
            *       • Too short timeout intervals may cause performance issues.
            *       • Too large timeout intervals may look fishy.
            */

            public constant real TIMER_TIMEOUT                        = 1./32.
           
            /**
            *   Owner of all Missile dummies. Should be a neutral player in your map.
            */

            public constant player NEUTRAL_PASSIVE                    = Player(15)
           
            /**
            *   Raw code of the dummy unit. Object Editor ( F6 )
            *       • Must be correct, otherwise missile dummies can neither be recycled nor destroyed.
            *       • Units of other type ids will not be thrown into the recycler bin.
            */

            public constant integer DUMMY_UNIT_ID                     = 'dumi'
       
            /**
            *   The maximum collision size used in your map. If unsure use 197. ( Town hall collision )
            *       • Applies for all types of widgets.
            *       • A precise value can improve Missile's performance,
            *         since smaller values enumerate less widgtes per loop per missile.
            */

            public constant real MAXIMUM_COLLISION_SIZE               = 197.
           
            /**
            *   Collision types for missiles. ( Documentation only )
            *   Missile decides internally each loop which type of collision is required.
            *       • Uses circular collision dectection for speed < collision. ( Good accuracy, best performance )
            *       • Uses rectangle collision for speed >= collision. ( Best accuracy, normal performance )
            */

            public constant integer COLLISION_TYPE_CIRCLE     = 0
            public constant integer COLLISION_TYPE_RECTANGLE  = 1
       
            /**
            *   Determine when rectangle collision is required to detect nearby widgets.
            *       • The smaller the factor the earlier rectangle collision is used. ( by default 1. )
            *       • Formula: speed >= collision*Missile_COLLISION_ACCURACY_FACTOR
            */

            public constant real    COLLISION_ACCURACY_FACTOR = 1.
       
    // Optional toogles:
    // ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
    //      Set booleans listed below to "true" and the compiler will write
    //      the feature into your map. Otherwise this code is completly ignored.                                        
    //          • Yay, I want that           --> "true"
    //          • Naah that's useless for me --> "false"
           
            /**
            *   USE_COLLISION_Z_FILTER enables z axis checks for widget collision. ( Adds minimal overhead )
            *   Use it when you need:
            *       • Missiles flying over or under widgets.
            *       • Determine between flying and walking units.
            */

            public constant boolean USE_COLLISION_Z_FILTER             = true
           
            /**
            *   WRITE_DELAYED_MISSILE_RECYCLING enables a delayed dummy recycling system. ( Very recommended )
            *   Use it if:
            *       • You use a dummy recycling library like MissileRecycler, Dummy or xedummy.
            *       • You want to properly display death animations of effects added to missiles.
            */

            public constant boolean WRITE_DELAYED_MISSILE_RECYCLING    = true
           
            /**
            *   DELAYED_MISSILE_DEATH_ANIMATION_TIME is the delay in seconds
            *   Missile holds back a dummy, before recycling it.
            *       • The time value does not have to be precise.
            *       • Requires WRITE_DELAYED_MISSILE_RECYCLING = true
            */

            private constant real DELAYED_MISSILE_DEATH_ANIMATION_TIME = 2.

            /**
            *   USE_DESTRUCTABLE_FILTER and USE_ITEM_FILTER are redundant constants from previous Missile versions.
            *   They do nothing, but remain for backwards compatibilty.
            *   From Missile version 1.5 on all widget collisions are always enabled.
            */

            public constant boolean USE_DESTRUCTABLE_FILTER            = true
            public constant boolean USE_ITEM_FILTER                    = true
        endglobals
    /*    
    *  3. Function configuration  
    *  ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
    *       Four functions to setup!
    */

        /**
        *   GetUnitBodySize(unit) returns a fictional value for z - axis collision.
        *   You have two options:
        *       • One constant value shared over all units.
        *       • Dynamic values based on handle id, type id, unit user data, scaling or other parameters.
        */

        function GetUnitBodySize takes unit whichUnit returns real
            return 100.// Other example: return LoadReal(hash, GetHandleId(whichUnit), KEY_UNIT_BODY_SIZE)
        endfunction

        /**
        *   Same as GetUnitBodySize, but for destructables.
        *   Using occluder height is an idea of mine. Of course you can use your own values.
        */

        function GetDestructableHeight takes destructable d returns real
            return GetDestructableOccluderHeight(d)// Other example: return 100.
        endfunction

        /**
        *   Same as GetUnitBodySize, but for items.
        *   Again it's up to you to figure out a fictional item height.
        */

        function GetItemHeight takes item i returns real
            return 16.
        endfunction
       
        /**
        *   Unit indexers and missiles ( Only if you don't use a dummy recycling library )
        *   ¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯¯
        *   It is most likely intended that projectiles don't run through a unit indexing process.
        *   ToogleUnitIndexer runs:
        *       • Directly before a dummy is created.
        *       • Directly after dummy unit creation.
        *
        *   Please return the previous setup of your indexing tool ( enabled, disabled ),
        *   so Missile can properly reset it to the original state.
        */

        private function ToogleUnitIndexer takes boolean enable returns boolean
            local boolean prev = true//UnitIndexer.enabled
            // set UnitIndexer.enabled = enable
            return prev
        endfunction
       
    /**  
    *   4. API
    *   ¯¯¯¯¯¯
    */

    //! novjass ( Disables the compiler until the next endnovjass )

            // Custom type Missile for your projectile needs.
            struct Missile extends array

            // Constants:
            // ==========
                //
                readonly static constant string ORIGIN = "origin"
                //  • Attach point name for fxs on dummies.

                readonly static constant real   HIT_BOX = (2./3.)
                //  • Fictional hit box for homing missiles.
                //    while 0 would be the toe and 1 the head of a unit.
               
            // Available creators:
            // ===================
                //
                static method createEx takes unit missileDummy, real impactX, real impactY, real impactZ returns Missile
                //  • Core creator method.
                //  • May launches any unit.
                //  • Units of type Missile_DUMMY_UNIT_ID get recycled in the end.
               
                static method create takes real x, real y, real z, real angleInRadians, real distanceToTravel, real endZ returns Missile
                //  • Converts arguments to fit into createEx, then calls createEx.

                static method createXYZ takes real x, real y, real z, real impactX, real impactY, real impactZ returns Missile
                //  • Converts arguments to fit into createEx, then calls createEx.
               
            // Available destructors:
            // ======================
                //
                return true
                //  • Core destructor.
                //  • Returning true in any of the interface methods of the MissileStruct module
                //    will destroy that instance instantly.
               
                method destroy   takes nothing returns nothing
                //  • Destroys the missile during the next timer callback.
               
                method terminate takes nothing returns nothing
                //  • Destroys the missile instantly.
               
            // Fields you can set and read directly:
            // =====================================
                //
                unit       source
                unit       target      // For homing missiles.
                real       distance    // Distance traveled.
                player     owner       // Pseudo owner for faster onCollide evaluation. The proper dummy owner remains PLAYER_NEUTRAL_PASSIVE.
                real       speed       // Vector lenght for missile movement in plane x / y. ( DOES NOT TAKE THE TIMER TIMEOUT IN ACCOUNT )
                real       acceleration
                real       damage
                real       turn        // Set a turn rate for missiles.
                integer    data        // For data transfer set and read data.  
                boolean    recycle     // Is automatically set to true, when a Missile reaches it's destination.
                boolean    wantDestroy // Set wantDestroy to true, to destroy a missile during the next timer callback.
               
                // Neither collision nor collisionZ accept values below zero.
                real       collision   // Collision size in plane x / y.
                real       collisionZ  // Collision size in z - axis. ( deprecated )
               
            // Fields you can only read:
            // =========================      
                //
                readonly boolean         allocated        
                readonly unit            dummy// The dummy unit of this missile.
           
                // Position members for you needs.
                readonly MissilePosition origin// Grants access to readonly members of MissilePosition,
                readonly MissilePosition impact// which are "x", "y", "z", "angle", "distance", "slope" and the pitch angle "alpha".
                                               // Furthermore method origin.move(x, y, z) and impact.move(x, y, z).
                readonly real            terrainZ
                readonly real            x
                readonly real            y
                readonly real            z
                readonly real            angle// Current angle in radians.

            // Method operators for set and read:
            // ==================================
                //
                method operator model= takes string modelFile returns nothing
                method operator model  takes nothing returns string
                //  • Adds an effect handle on a missile dummy to it's "origin".
                //  • You can read the file path.
                //  • For multiple effects access "this.dummy" in your struct.
                 
                method operator scale= takes real value returns nothing
                method operator scale  takes nothing returns real
                //  • Set and read the scaling of the dummy unit.  
               
                method operator curve= takes real value returns nothing
                method operator curve  takes nothing returns real
                //  • Enables curved movement for your missile. ( Pass in radians, NOT degrees )
                //  • Do not pass in PI/2.
           
                method operator arc=   takes real value returns nothing
                method operator arc    takes nothing returns real
                //  • Enables arcing movement for your missile. ( Pass in radians, NOT degrees )
                //  • Do not pass in PI/2.
                           
            // Methods for missile movement:
            // =============================
                //
                method bounce           takes nothing returns nothing
                //  • Moves the MissilePosition "origin" to the current missile coordinates.
                //  • Resets the distance traveled to 0.
               
                method deflect          takes real tx, real ty returns nothing
                //  • Deflect the missile towards tx, ty. Then calls bounce.        
               
                method deflectEx        takes real tx, real ty, real tz returns nothing
                //  • Deflect the missile towards tx, ty, tz. Then calls bounce.
       
                method flightTime2Speed takes real duration returns nothing
                //  • Converts a fly time to a vector lenght for member "speed".
                //  • Does not take acceleration into account. ( Disclaimer )
           
                method setMovementSpeed takes real value returns nothing
                //  • Converts Warcraft III movement speed to a vector lenght for member "speed".
           
            // Methods for missile collision: ( all are hashtable entries )
            // ==============================
                // By default a widget can only be hit once per missile.
                //
                method hitWidget        takes widget w returns nothing
                //  • Saves a widget in the memory as hit by this instance.
           
                method hasHitWidget     takes widget w returns boolean
                //  • Returns true, if "w" has been hit by this instance.
           
                method removeHitWidget  takes widget w returns nothing
                //  • Removes a widget from this missile's memory for widget collision. ( Can hit "w" again )
               
                method flushHitWidgets  takes nothing returns nothing
                //  • Flushes a missile's memory for widget collision. ( All widgets can be hit again )
               
                method enableHitAfter   takes widget w, real seconds returns nothing
                //  • Automatically calls removeHitWidget(w) after "seconds" time. ( Can hit "w" again after given time )
               
            // Module MissileStruct:
            // =====================
                //
                module MissileLaunch // ( optional )
                module MissileStruct
                //  • Enables the entire missile interface for that struct.
               
            // Interface in structs: ( Must implement module MissileStruct )
            // =====================
                //
                //  • Write one, many or all of the static method below into your struct.
                //  • Missiles launched in this struct will run those methods, when their events fire.
                //
                //  • All of those static methods must return a boolean.
                //      a) return true  --> destroys the missile instance instantly.
                //      b) return false --> keep on flying.

            // Available static method:  
            // ========================
                //
                static method onCollide            takes Missile missile, unit hit returns boolean
                //  • Runs for units in collision range of a missile.

                static method onDestructable       takes Missile missile, destructable hit returns boolean
                //  • Runs for destructables in collision range of a missile.

                static method onItem               takes Missile missile, item hit returns boolean
                //  • Runs for items in collision range of a missile.
               
                static method onTerrain takes Missile missile returns boolean
                //  • Runs when a missile collides with the terrain. ( Ground and cliffs )
               
                static method onFinish  takes Missile missile returns boolean
                //  • Runs only when a missile reaches it's destination.
                //  • However does not run, if a Missile is destroyed in another method.
               
                static method onPeriod  takes Missile missile returns boolean
                //  • Runs every Missile_TIMER_TIMEOUT seconds.

                static method onRemove takes Missile missile returns boolean
                //  • Runs when a missile is destroyed.
                //  • Unlike onFinish, onRemove will runs ALWAYS when a missile is destroyed!!!
                //  
                //  For onRemove the returned boolean has a unique meaning:
                //  • Return true will recycle this missile delayed. ( Only if WRITE_DELAYED_MISSILE_RECYCLING = true )
                //  • Return false will recycle this missile right away.
               
                static method launch takes Missile toLaunch returns nothing
                //  • Well ... Launches this Missile.
                //  • Missile "toLaunch" will behave as declared in the struct. ( static methods from above )
               
        // Misc: ( From the global setup )
        // =====
            //
            // Constants:
            // ==========
                //
                public constant real    TIMER_TIMEOUT                
                public constant player  NEUTRAL_PASSIVE            
                public constant integer DUMMY_UNIT_ID                
                public constant real    MAXIMUM_COLLISION_SIZE          
                public constant boolean USE_COLLISION_Z_FILTER            
                public constant boolean WRITE_DELAYED_MISSILE_RECYCLING    
                public constant boolean USE_DESTRUCTABLE_FILTER            
                public constant boolean USE_ITEM_FILTER  
               
                readonly static constant string ORIGIN
                readonly static constant real   HIT_BOX
           
            // Functions:
            // ==========
                //
                public function GetLocZ               takes real x, real y returns real
                       function GetUnitBodySize       takes unit whichUnit returns real
                       function GetDestructableHeight takes destructable d returns real
                       function GetItemHeight         takes item i returns real
             
    //========================================================================
    // Missile system. Make changes carefully.
    //========================================================================

    //! endnovjass ( Enables the compiler )

    // Hello and welcome to Missile.
    // I wrote a guideline for every piece of code inside Missile, so you
    // can easily understand how the it gets compiled and evaluated.
    //
    // Let's go!
           
        globals
            // Core constant handle variables of Missile.
            private constant trigger   CORE  = CreateTrigger()
            private constant trigger   MOVE  = CreateTrigger()
            private constant timer     TMR   = CreateTimer()
            private constant location  LOC   = Location(0., 0.)
            private constant rect      RECT  = Rect(0., 0., 0., 0.)
            private constant group     GROUP = CreateGroup()
            private constant hashtable HASH  = InitHashtable()
            // For starting and stopping the timer.
            private integer active = 0
            // Arrays for data structure.
            private integer          array   instances
            private Missile          array   missileList
            private boolexpr         array   expression
            private triggercondition array   condition
            private integer          array   remove
            private boolean          array   destroying
            private boolean          array   recycling
            private integer          array   nextNode
            private integer          array   prevNode
            // Internal widget filter functions.
            private boolexpr destFilter
            private boolexpr itemFilter
            private boolexpr unitFilter
        endglobals
       
        public function GetLocZ takes real x, real y returns real
            call MoveLocation(LOC, x, y)
            return GetLocationZ(LOC)
        endfunction
       
        // For WRITE_DELAYED_MISSILE_RECYCLING = true Missile will hold back
        // dummies for DELAYED_MISSILE_DEATH_ANIMATION_TIME before they are recylced. ( Code placed in a static if )
        //
        //! runtextmacro optional WRITE_MISSILE_RECYCLE_BIN("WRITE_DELAYED_MISSILE_RECYCLING", "DELAYED_MISSILE_DEATH_ANIMATION_TIME")
       
        // The code of WRITE_MISSILE_POSITION_CODE boxes a missiles position and does the required trigonometry.
        //
        //! runtextmacro WRITE_MISSILE_POSITION_CODE()
       
        // Missiles structure works like a linked list with the folling methods:
        // allocateCollection(), allocateNode(), insertFront(node) and remove()
        //
        private keyword MissileStructure
        struct Missile extends array
            implement MissileStructure

            // Constants:
            // ==========
            //
            // Attach point name for effects created by model=.
            readonly static constant string ORIGIN = "origin"
           
            // Set a ficitional hit box in range of 0 to 1,
            // while 0 is the toe and 1 the head of a unit.
            readonly static constant real HIT_BOX  = (2./3.)
           
            // DEBUG_MODE only members:
            // ========================
            //
            // Checks for double launching. Throws an error message.
            debug boolean launched

            // Private members:
            // ================
            //        
            // The position of a missile using curve= does not
            // match the position used by Missile's trigonometry.
            // Therefore we need this member two times.
            // Readable x / y / z for your needs and posX / posY for cool mathematics.
            private real posX
            private real posY
            private real dist// distance
           
            // Readonly members:
            // =================
            //
            // Prevents a double free case.
            readonly boolean allocated
           
            // The dummy unit.
            readonly unit    dummy
           
            // Position members for your needs.
            readonly MissilePosition origin// Grants access to readonly members of MissilePosition,
            readonly MissilePosition impact// which are "x", "y", "z", "angle", "distance", "slope" and "alpha".
            readonly real            terrainZ
            readonly real            x
            readonly real            y
            readonly real            z
            readonly real            angle// Current angle
            readonly real            prevX
            readonly real            prevY
            readonly real            prevZ
           
            // Collision detection type. ( Evaluated new in each loop )
            readonly integer         collisionType// Current collision type ( circular or rectangle )
           
            // Members you can set:
            // ====================
            //
            unit       source
            unit       target      // For homing missiles.
            real       distance    // Distance traveled.
            player     owner       // Pseudo owner for faster onCollide evaluation. The proper dummy owner is PLAYER_NEUTRAL_PASSIVE.
            real       speed       // Vector lenght for missile movement in plane x / y.
            real       acceleration
            real       damage
            integer    data        // For data transfer set and read data.  
            boolean    recycle     // Is set to true, when a Missile reaches it's destination.
            real       turn        // Sets a turn rate for a missile.
            real       collision   // Collision size in plane x / y.

            // Setting collision z is deprecated since Missile v2.5.
            method operator collisionZ= takes real value returns nothing
            endmethod
            method operator collisionZ takes nothing returns real
                return collision
            endmethod
           
            // Operator overloading:
            // =====================
            //
            // Special effect on the missile dummy. For multiple effect attaching, access unit "dummy" directly.
            private effect sfx
            private string path
            method operator model= takes string file returns nothing
                if sfx != null then
                    call DestroyEffect(sfx)
                    set sfx = null
                endif
                                        // null and ""
                if StringLength(file) > 0 then
                    set sfx = AddSpecialEffectTarget(file, dummy, ORIGIN)
                    set path = file
                else
                    set path = null
                endif
            endmethod
            method operator model takes nothing returns string
                return path
            endmethod
           
            real open
           // Enables curved movement for your missile.
           // Remember that the result of Tan(PI/2) is infinity.
            method operator curve= takes real value returns nothing
                set open = Tan(value)*origin.distance
            endmethod
            method operator curve takes nothing returns real
                return Atan(open/origin.distance)
            endmethod
           
            real height
            // Enables arcing movement for your missile.
            method operator arc= takes real value returns nothing
                set height = Tan(value)*origin.distance/4
            endmethod
            method operator arc takes nothing returns real
                return Atan(4*height/origin.distance)
            endmethod
           
            private real scaling
            method operator scale= takes real value returns nothing
                call SetUnitScale(dummy, value, 0., 0.)
                set scaling = value
            endmethod
            method operator scale takes nothing returns real
                return scaling
            endmethod
           
            // Methods:
            // ========
            //
            method bounce takes nothing returns nothing
                call origin.move(x, y, z)
                set dist = 0.
            endmethod
           
            method deflect takes real tx, real ty returns nothing
                local real a = 2.*Atan2(ty - y, tx - x) + bj_PI - angle
                call impact.move(x + (origin.distance - dist)*Cos(a), y + (origin.distance - dist)*Sin(a), impact.z)
                call bounce()
            endmethod
           
            method deflectEx takes real tx, real ty, real tz returns nothing
                call impact.move(impact.x, impact.y, tz)
                call deflect(tx, ty)
            endmethod
       
            method flightTime2Speed takes real duration returns nothing
                set speed = RMaxBJ(0.00000001, (origin.distance - dist)*Missile_TIMER_TIMEOUT/RMaxBJ(0.00000001, duration))
            endmethod
           
            method setMovementSpeed takes real value returns nothing
                set speed = value*Missile_TIMER_TIMEOUT
            endmethod
       
            boolean wantDestroy// For "true" a missile is destroyed on the next timer callback. 100% safe.
            method destroy takes nothing returns nothing
                set wantDestroy = true
            endmethod

            // Instantly destroys a missile.
            method terminate takes nothing returns nothing
                if allocated then
                    call remove()
                    call impact.destroy()
                    call origin.destroy()
               
                    call DestroyEffect(sfx)
                    call FlushChildHashtable(HASH, this)
                    if GetUnitTypeId(dummy) == Missile_DUMMY_UNIT_ID then
                        // MissileRecycler > Dummy > xe.
                        static if LIBRARY_MissileRecycler then
                            call RecycleMissile(dummy)
                        elseif LIBRARY_Dummy and Dummy.create.exists then
                            call Dummy[dummy].destroy()
                        elseif LIBRARY_xedummy and xedummy.release.exists then
                            call xedummy.release(dummy)
                        else
                            call RemoveUnit(dummy)
                        endif
                    endif
                    set sfx = null
                    set source = null
                    set target = null
                    set dummy = null
                    set owner = null
                endif
            endmethod
           
            // Runs in createEx.
            //! textmacro MISSILE_RESET_ALL_MEMBERS
                set path = null
                set speed = 0.
                set acceleration = 0.
                set distance = 0.
                set dist = 0
                set dist = 0.
                set height = 0.
                set turn = 0.
                set open = 0.
                set collision = 0.
                set collisionType = 0
                set stackSize = 0
                set scaling = 1.
                set wantDestroy = false
                set recycle = false
            //! endtextmacro
       
            // Launches a dummy of your choice.
            static method createEx takes unit missileDummy, real impactX, real impactY, real impactZ returns thistype
                local thistype this = thistype.allocateNode()
                local real originX  = GetUnitX(missileDummy)
                local real originY  = GetUnitY(missileDummy)
                local real originZ  = GetUnitFlyHeight(missileDummy)
                //
                //! runtextmacro MISSILE_RESET_ALL_MEMBERS()
                //
                set origin = MissilePosition.create(originX, originY, originZ)
                set impact = MissilePosition.create(impactX, impactY, impactZ)
                call MissilePosition.link(origin, impact)
                           
                set posX      = originX
                set posY      = originY
                set x         = originX
                set y         = originY
                set z         = originZ
                set angle     = origin.angle
                set dummy     = missileDummy
               
                call SetUnitFlyHeight(missileDummy, originZ, 0.)  
                call SaveUnitHandle(HASH, this, GetHandleId(missileDummy), missileDummy)
                //
                static if LIBRARY_ErrorMessage then
                    debug call ThrowWarning(GetUnitTypeId(missileDummy) == 0, "Missile", "createEx", "missileDummy", this, "Invalid missile dummy unit ( null )!")
                endif
                debug set launched = false
                return this
            endmethod
       
            // Freaky static if ensures these libraries really don't exist.
            static if not LIBRARY_MissileRecycler and not LIBRARY_Dummy and not Dummy.create.exists and not LIBRARY_xe_dummy and not xe_dummy.new.exists then
                private static method newMissileUnit takes real x, real y, real z, real face returns unit
                    local boolean prev = ToogleUnitIndexer(false)
                    set bj_lastCreatedUnit = CreateUnit(Missile_NEUTRAL_PASSIVE, Missile_DUMMY_UNIT_ID , x, y, face)
                    call ToogleUnitIndexer(prev)
                    call SetUnitX(bj_lastCreatedUnit, x)
                    call SetUnitY(bj_lastCreatedUnit, y)
                    call UnitAddAbility(bj_lastCreatedUnit, 'Amrf')
                    call SetUnitFlyHeight(bj_lastCreatedUnit, z, 0.)
                    call PauseUnit(bj_lastCreatedUnit, true)
                    return bj_lastCreatedUnit
                endmethod
            endif
       
            // MissileRecylcer > Dummy > xe > Missile.
            //! textmacro MISSILE_GET_DUMMY_FROM_LIBRARY
                static if LIBRARY_MissileRecycler then
                    return createEx(GetRecycledMissile(x, y, z, angle*bj_RADTODEG), impactX, impactY, impactZ)
           
                elseif LIBRARY_Dummy and Dummy.create.exists then
                    local Dummy dummy = Dummy.create(x, y, angle*bj_RADTODEG)
                    call SetUnitFlyHeight(dummy.unit, z, 0.)
                    return createEx(dummy.unit, impactX, impactY, impactZ)
           
                elseif LIBRARY_xedummy and xedummy.new.exists then
                    set bj_lastCreatedUnit = xedummy.new(Missile_NEUTRAL_PASSIVE, x, y, angle*bj_RADTODEG)
                    call SetUnitFlyHeight(bj_lastCreatedUnit, z, 0.)
                    return createEx(bj_lastCreatedUnit, impactX, impactY, impactZ)
               
                else
                    return createEx(Missile.newMissileUnit(x, y, z, angle*bj_RADTODEG), impactX, impactY, impactZ)
                endif
            //! endtextmacro
       
            // Wrapper to createEx.
            static method create takes real x, real y, real z, real angle, real distance, real impactZ returns thistype
                local real impactX = x + distance*Cos(angle)
                local real impactY = y + distance*Sin(angle)
                // Get the dummy unit.
                //! runtextmacro MISSILE_GET_DUMMY_FROM_LIBRARY()
            endmethod
           
            // Wrapper to createEx.
            static method createXYZ takes real x, real y, real z, real impactX, real impactY, real impactZ returns thistype
                local real angle = Atan2(impactY - y, impactX - x)
                // Get the dummy unit.
                //! runtextmacro MISSILE_GET_DUMMY_FROM_LIBRARY()
            endmethod
       
            // Missile motion takes place every Missile_TIMER_TIMEOUT
            // before accessing each active struct.
            static Missile temp = 0
            static method move takes nothing returns boolean
                local integer loops = 0   // Current iteration.
                local integer limit = 150 // Set iteration border per trigger evaluation to avoid hitting the operation limit.
                local thistype this = thistype.temp
               
                local MissilePosition p
                local real a
                local real d
                local unit u
                local real newX
                local real newY
                local real vel
                local real point
                local real pitch
                loop
                    exitwhen 0 == this or loops == limit
                    set p = origin
                   
                    // Save previous, respectively current missile position.
                    set prevX = x
                    set prevY = y
                    set prevZ = z
                   
                    // Evaluate the collision type.
                    set vel = speed
                    set speed = vel + acceleration
                    if vel < collision*Missile_COLLISION_ACCURACY_FACTOR then
                        set collisionType = Missile_COLLISION_TYPE_CIRCLE
                    else
                        set collisionType = Missile_COLLISION_TYPE_RECTANGLE
                    endif
                   
                    // Update missile guidance to its intended target.
                    set u = target
                    if u != null then
                        if 0 == GetUnitTypeId(u) then
                            set target = null
                        else
                            call origin.move(x, y, z)
                            call impact.move(GetUnitX(u), GetUnitY(u), GetUnitFlyHeight(u) + GetUnitBodySize(u)*Missile.HIT_BOX)
                            set dist = 0
                            set height = 0
                            set curve = 0
                        endif
                    endif
                    set a = p.angle
                   
                    // Update the missile facing angle depending on the turn ratio.
                    if 0. != turn and Cos(angle - a) < Cos(turn) then
                        if 0. > Sin(a - angle) then
                            set angle = angle - turn
                        else
                            set angle = angle + turn
                        endif
                    else
                        set angle = a
                    endif
                   
                    // Update the missile position on the parabola.
                    set d = p.distance// origin - impact distance.
                   
                    set recycle = dist + vel >= d
                    if recycle then// Maximum distance reached.
                        set point = d
                        set distance = distance + d - dist
                    else
                        set distance = distance + vel
                        set point = dist + vel
                    endif
                    set dist = point
                   
                    set newX  = posX + vel*Cos(angle)
                    set newY  = posY + vel*Sin(angle)
                    set posX  = newX
                    set posY  = newY
                   
                    // Update point(x/y) if a curving trajectory is defined.
                    set u = dummy
                    if 0. != open and target == null then
                        set vel = 4*open*point*(d - point)/p.square
                        set a = angle + bj_PI/2
                        set newX = newX + vel*Cos(a)
                        set newY = newY + vel*Sin(a)
                        set a = angle + Atan(-((4*open)*(2*point - d))/p.square)
                    else
                        set a = angle
                    endif
                    set x = newX
                    set y = newY
                   
                    // Update pos z if an arc or height is set.
                    call MoveLocation(LOC, newX, newY)
                    set terrainZ = GetLocationZ(LOC)
                    set pitch = p.alpha
                    if 0. == height and 0. == pitch then
                        set z = p.z - terrainZ
                    else
                        set z = p.z - terrainZ + p.slope*point
                        if 0. != height and target == null then
                            set z = z + (4*height*point*(d - point)/p.square)
                            set pitch = pitch - Atan(((4*height)*(2*point - d))/p.square)*bj_RADTODEG
                        endif
                    endif
                    // Update the pitch angle of the dummy unit.
                    if GetUnitTypeId(u) == Missile_DUMMY_UNIT_ID then
                        call SetUnitAnimationByIndex(u, R2I(pitch + 90.5))
                    endif
                   
                    // Move the missile dummy via native.
                    call SetUnitFlyHeight(u, z, 0.)
                    call SetUnitFacing(u, a*bj_RADTODEG)
                   
                    // WorldBounds > BoundSentinel.
                    static if not LIBRARY_BoundSentinel and not LIBRARY_WorldBounds then
                        if RectContainsCoords(bj_mapInitialPlayableArea, newX, newY) then
                            call SetUnitX(u, newX)
                            call SetUnitY(u, newY)
                        endif                    
                    elseif LIBRARY_WorldBounds then
                        if newX < WorldBounds.maxX and newX > WorldBounds.minX and newY < WorldBounds.maxY and newY > WorldBounds.minY then
                            call SetUnitX(u, newX)
                            call SetUnitY(u, newY)
                        endif                
                    else
                        call SetUnitX(u, newX)
                        call SetUnitY(u, newY)
                    endif
                   
                    set loops = loops + 1
                    set this = nextNode[this]
                endloop
               
                set u = null
                set thistype.temp = this
                return this == 0
            endmethod
               
            // Widget collision API:
            // =====================
            //
            // Runs automatically on widget collision.
            method hitWidget takes widget w returns nothing
                if w != null then
                    call SaveWidgetHandle(HASH, this, GetHandleId(w), w)
                endif
            endmethod
           
            // All widget which have been hit return true.
            method hasHitWidget takes widget w returns boolean
                return HaveSavedHandle(HASH, this, GetHandleId(w))
            endmethod
           
            // Removes a widget from the missile's memory of hit widgets. ( This widget can be hit again )
            method removeHitWidget takes widget w returns nothing
                if w != null then
                    call RemoveSavedHandle(HASH, this, GetHandleId(w))
                endif
            endmethod
           
            // Flushes a missile's memory for collision. ( All widgets can be hit again )
            method flushHitWidgets takes nothing returns nothing
                call FlushChildHashtable(HASH, this)
                call hitWidget(dummy)
            endmethod
           
            // Tells missile to call removeHitWidget(w) after "seconds" time.
            // Does not apply to widgets, which are already hit by this missile.
            readonly integer stackSize
            method enableHitAfter takes widget w, real seconds returns nothing
                local integer id = GetHandleId(w)
                if w != null then
                    if not HaveSavedInteger(HASH, this, id) then
                        call SaveInteger(HASH, this, id, stackSize)
                        call SaveInteger(HASH, this, stackSize, id)
                        set stackSize = stackSize + 1
                    endif
                    call SaveReal(HASH, this, id, seconds)// Set time.
                endif
            endmethod
           
            method updateStack takes nothing returns nothing
                local integer dex = 0
                local integer id
                local real time
                loop
                    exitwhen dex == stackSize
                    set id = LoadInteger(HASH, this, dex)
                    set time = LoadReal(HASH, this, id) - Missile_TIMER_TIMEOUT
                    if time <= 0. or not HaveSavedHandle(HASH, this, id) then
                        set stackSize = stackSize - 1
                        set id = LoadInteger(HASH, this, stackSize)
                        call SaveInteger(HASH, this, dex, id)
                        call SaveInteger(HASH, this, id, dex)
                        // Enables hit.
                        call RemoveSavedHandle(HASH, this, id)
                        // Remove data from stack.
                        call RemoveSavedReal(HASH, this, id)
                        call RemoveSavedInteger(HASH, this, id)
                        call RemoveSavedInteger(HASH, this, stackSize)
                    else
                        call SaveReal(HASH, this, id, time)
                        set dex = dex + 1
                    endif
                endloop
            endmethod
       
            // Widget collision code:
            // ======================
            //
            private static boolean circle = true
            //
            // 1.) Rectangle collision for fast moving missiles with small collision radius.
            //        
            // Runs for destructables and items in a rectangle.
            // Checks if widget w is in collision range of a missile.
            // Is not precise in z - axis collision.
            private method isWidgetInRectangle takes widget w, real wz, real distance returns boolean
                local real wx = GetWidgetX(w)
                local real wy = GetWidgetY(w)
                local real dz = Missile_GetLocZ(wx, wy) - terrainZ
                local real dx = x - prevX
                local real dy = y - prevY
                local real s  = (dx*(wx - prevX) + dy*(wy - prevY))/(dx*dx + dy*dy)  
               
                if s < 0. then
                    set s = 0.
                elseif s > 1 then
                    set s = 1.
                endif
                set dx = (prevX + s*dx) - wx
                set dy = (prevY + s*dy) - wy

                return dx*dx + dy*dy <= distance*distance and dz + wz >= z - distance and dz <= z + distance
            endmethod        
            //
            // 2.) Circular collision detection for all other missiles.
            //
            // Returns true for widgets in a xyz collision range.
            private method isWidgetInRange takes widget w, real wz, real distance returns boolean
                local real wx = GetWidgetX(w)
                local real wy = GetWidgetY(w)
                local real dz = Missile_GetLocZ(wx, wy) - terrainZ
                //     collision in plane x and y,            collision in z axis.
                return IsUnitInRangeXY(dummy, wx, wy, distance) and dz + wz >= z - distance and dz <= z + distance
            endmethod        
            //
            //  3.) Action functions inside the widget enumeration thread.
            //
            // Runs for every enumerated destructable.
            //  • Directly filters out already hit destructables.
            //  • Distance formula based on the Pythagorean theorem.
            //                        
            private static method filterDests takes nothing returns boolean
                local destructable d = GetFilterDestructable()
                local boolean b = false
                if not HaveSavedHandle(HASH, temp, GetHandleId(d)) then
                    if circle then                          
                        set b = temp.isWidgetInRange(d, GetDestructableHeight(d), temp.collision)
                    else
                        set b = temp.isWidgetInRectangle(d, GetDestructableHeight(d), temp.collision)
                    endif
                endif
                set d = null
                return b
            endmethod
            //
            // Runs for every enumerated item.
            //  • Directly filters out already hit items.
            //  • Distance formula based on the Pythagorean theorem.
            //  • Items have a fix collision size of 16.
            //
            private static method filterItems takes nothing returns boolean
                local item i = GetFilterItem()
                local boolean b = false
                if not HaveSavedHandle(HASH, temp, GetHandleId(i)) then
                    if circle then                                        // Item in missile collision size or item pathing in missile range.
                        set b = temp.isWidgetInRange(i, GetItemHeight(i), RMaxBJ(temp.collision, 16.))
                    else
                        set b = temp.isWidgetInRectangle(i, GetItemHeight(i), RMaxBJ(temp.collision, 16.))
                    endif
                endif
                set i = null
                return b
            endmethod
            //
            //  4.) Filter function for rectangle unit collision.
            //
            // Runs for every enumerated units.
            //  • Filters out units which are not in collision range in plane x / y.
            //  • Inlined and therefore a bit faster than item and destructable collision.
            //
            private static method filterUnits takes nothing returns boolean
                local thistype this = thistype.temp
                local unit u = GetFilterUnit()
                local real dx
                local real dy
                local real s
                local boolean is = false
               
                if not HaveSavedHandle(HASH, this, GetHandleId(u)) then
                    set dx = x - prevX
                    set dy = y - prevY
                    set s = (dx*(GetUnitX(u) - prevX) + dy*(GetUnitY(u)- prevY))/(dx*dx + dy*dy)
                    if s < 0. then
                        set s = 0.
                    elseif s > 1. then
                        set s = 1.
                    endif
                    set is = IsUnitInRangeXY(u, prevX + s*dx, prevY + s*dy, collision)
                endif
               
                set u = null
                return is
            endmethod
            //
            // 5.) Proper rect preparation.
            //
            // For rectangle.
            private method prepareRectRectangle takes nothing returns nothing
                local real x1 = prevX
                local real y1 = prevY
                local real x2 = x
                local real y2 = y
                local real d = collision + Missile_MAXIMUM_COLLISION_SIZE
                // What is min, what is max ...
                if x1 < x2 then
                    if y1 < y2 then
                        call SetRect(RECT, x1 - d, y1 - d, x2 + d, y2 + d)
                    else
                        call SetRect(RECT, x1 - d, y2 - d, x2 + d, y1 + d)
                    endif
                elseif y1 < y2 then
                    call SetRect(RECT, x2 - d, y1 - d, x1 + d, y2 + d)
                else
                    call SetRect(RECT, x2 - d, y2 - d, x1 + d, y1 + d)
                endif
            endmethod
            //
            // For circular.
            private method prepareRectCircle takes nothing returns nothing
                local real d = collision + Missile_MAXIMUM_COLLISION_SIZE
                call SetRect(RECT, x - d, y - d, x + d, y + d)
            endmethod
            //
            // 5.) API for the MissileStruct iteration.
            //
            method groupEnumUnitsRectangle takes nothing returns nothing
                call prepareRectRectangle()
                set thistype.temp = this
                call GroupEnumUnitsInRect(GROUP, RECT, unitFilter)
            endmethod
            //
            // Prepares destructable enumeration, then runs enumDests.
            method checkDestCollision takes code func returns nothing
                set circle = collisionType == Missile_COLLISION_TYPE_CIRCLE
                if circle then
                    call prepareRectCircle()
                else
                    call prepareRectRectangle()
                endif
                //
                set thistype.temp = this
                call EnumDestructablesInRect(RECT, destFilter, func)
            endmethod
            //
            // Prepares item enumeration, then runs enumItems.
            method checkItemCollision takes code func returns nothing
                set circle = collisionType == Missile_COLLISION_TYPE_CIRCLE
                if circle then
                    call prepareRectCircle()
                else
                    call prepareRectRectangle()
                endif
                //
                set thistype.temp = this
                call EnumItemsInRect(RECT, itemFilter, func)
            endmethod

    static if Missile_WRITE_DELAYED_MISSILE_RECYCLING then
        method nullBefore takes nothing returns nothing
            set dummy = null
        endmethod
    endif

    // Does not check for 'Aloc' and 'Amrf' as they could be customized.
            private static method onInit takes nothing returns nothing
                static if LIBRARY_ErrorMessage then
                    debug local boolean prev = ToogleUnitIndexer(false)
                    debug local unit dummy = CreateUnit(Missile_NEUTRAL_PASSIVE, Missile_DUMMY_UNIT_ID, 0., 0., 0.)
                    debug call ToogleUnitIndexer(prev)
                    //
                    debug call ThrowError((GetUnitTypeId(dummy) != Missile_DUMMY_UNIT_ID), "Missile", "DEBUG_MISSILE", "type id",    0, "Global setup for public integer DUMMY_UNIT_ID is incorrect! This map currently can't use Missile!")
                    debug call ThrowError((Missile_MAXIMUM_COLLISION_SIZE < 0),            "Missile", "DEBUG_MISSILE", "collision",  0, "Global setup for public real MAXIMUM_COLLISION_SIZE is incorrect, below zero! This map currently can't use Missile!")
                    debug call RemoveUnit(dummy)
                    debug set dummy = null
                endif
                //
                set unitFilter = Filter(function thistype.filterUnits)
                set destFilter = Filter(function thistype.filterDests)
                set itemFilter = Filter(function thistype.filterItems)
                call TriggerAddCondition(MOVE, Condition(function thistype.move))
            endmethod
           
        endstruct
        // You made it to the end of Missile, but we are not finished.
        // Do you remember about the data structure, the delayed recycler
        // and of course our interface module "MissileStruct"
        //
        // This comes now!
       
        // Debug code taken from List ( full credits to Nestharus )
        private module MissileStructure
            private static thistype collectionCount = 0
            private static thistype nodeCount       = 0
           
            static if LIBRARY_ErrorMessage then
                debug private boolean isNode
                debug private boolean isCollection
            endif
           
            private thistype _list
            method operator list takes nothing returns thistype
                static if LIBRARY_ErrorMessage then
                    debug call ThrowError(this == 0,    "MissileStructure", "list", "thistype", this, "Attempted To Read Null Node.")
                    debug call ThrowError(not isNode,   "MissileStructure", "list", "thistype", this, "Attempted To Read Invalid Node.")
                endif
                return _list
            endmethod
           
            private thistype _next
            method operator next takes nothing returns thistype
                static if LIBRARY_ErrorMessage then
                    debug call ThrowError(this == 0,    "MissileStructure", "next", "thistype", this, "Attempted To Go Out Of Bounds.")
                    debug call ThrowError(not isNode,   "MissileStructure", "next", "thistype", this, "Attempted To Read Invalid Node.")
                endif
                return _next
            endmethod
           
            private thistype _prev
            method operator prev takes nothing returns thistype
                static if LIBRARY_ErrorMessage then
                    debug call ThrowError(this == 0,    "MissileStructure", "prev", "thistype", this, "Attempted To Go Out Of Bounds.")
                    debug call ThrowError(not isNode,   "MissileStructure", "prev", "thistype", this, "Attempted To Read Invalid Node.")
                endif
                return _prev
            endmethod
           
            private thistype _first
            method operator first takes nothing returns thistype
                static if LIBRARY_ErrorMessage then
                    debug call ThrowError(this == 0,        "MissileStructure", "first", "thistype", this, "Attempted To Read Null List.")
                    debug call ThrowError(not isCollection, "MissileStructure", "first", "thistype", this, "Attempted To Read Invalid List.")
                endif
                return _first
            endmethod
           
            private thistype _last
            method operator last takes nothing returns thistype
                static if LIBRARY_ErrorMessage then
                    debug call ThrowError(this == 0,        "MissileStructure", "last", "thistype", this, "Attempted To Read Null List.")
                    debug call ThrowError(not isCollection, "MissileStructure", "last", "thistype", this, "Attempted To Read Invalid List.")
                endif
                return _last
            endmethod
           
            static method allocateCollection takes nothing returns thistype
                local thistype this = thistype(0)._first
               
                if (0 == this) then
                    static if LIBRARY_ErrorMessage then
                        debug call ThrowError(collectionCount == 8191, "MissileStructure", "allocateCollection", "thistype", 0, "Overflow.")
                    endif
                   
                    set this = collectionCount + 1
                    set collectionCount = this
                else
                    set thistype(0)._first = _first
                endif
               
                static if LIBRARY_ErrorMessage then
                    debug set isCollection = true
                endif
               
                set _first = 0
               
                return this
            endmethod
           
            static method allocateNode takes nothing returns thistype
                local thistype this = thistype(0)._next
               
                if (0 == this) then
                    static if LIBRARY_ErrorMessage then
                        debug call ThrowError(nodeCount == 8191, "MissileStructure", "allocateNode", "thistype", 0, "Overflow.")
                    endif
                   
                    set this = nodeCount + 1
                    set nodeCount = this
                else
                    set thistype(0)._next = _next
                endif
               
                set allocated = true
               
                return this
            endmethod
           
            method insertFront takes thistype node returns thistype
               
                // Extra static unique list for missile motion.
                set nextNode[node] = 0
                set prevNode[node] = prevNode[0]
                set nextNode[prevNode[0]] = node
                set prevNode[0] = node
               
                static if LIBRARY_ErrorMessage then
                    debug call ThrowError(this == 0,        "List", "push", "thistype", this, "Attempted To Push On To Null List.")
                    debug call ThrowError(not isCollection, "List", "push", "thistype", this, "Attempted To Push On To Invalid List.")
                    debug set node.isNode = true
                endif
               
                set node._list = this
           
                if (_first == 0) then
                    set _first = node
                    set _last = node
                    set node._next = 0
                else
                    set _first._prev = node
                    set node._next = _first
                    set _first = node
                endif
               
                set node._prev = 0
               
                return node
            endmethod
         
            method remove takes nothing returns nothing
                local thistype node = this
                set this = node._list
               
                static if LIBRARY_ErrorMessage then
                    debug call ThrowError(node == 0,        "MissileStructure", "remove", "thistype", this, "Attempted To Remove Null Node.")
                    debug call ThrowError(not node.isNode,  "MissileStructure", "remove", "thistype", this, "Attempted To Remove Invalid Node (" + I2S(node) + ").")
                    debug set node.isNode = false
                endif
               
                set node._list = 0
           
                if (0 == node._prev) then
                    set _first = node._next
                else
                    set node._prev._next = node._next
                endif
                if (0 == node._next) then
                    set _last = node._prev
                else
                    set node._next._prev = node._prev
                endif
               
                set node._next = thistype(0)._next
                set thistype(0)._next = node
               
                set node.allocated = false
               
                // Static unique list for missile motion.
                set nextNode[prevNode[node]] = nextNode[node]
                set prevNode[nextNode[node]] = prevNode[node]
            endmethod
        endmodule

        // Boolean expressions per struct:
        // ===============================
        //    
        // Condition function for the core trigger evaluation. ( Runs for all struct using module MissileStruct )
        private function MissileCreateExpression takes integer structId, code func returns nothing
            set expression[structId] = Condition(func)
        endfunction
       
        // Creates a collection for a struct. ( Runs for all struct using module MissileStruct )
        private function MissileCreateCollection takes integer structId returns nothing
            set missileList[structId] = Missile.allocateCollection()
        endfunction
       
        // Core:
        // =====
        //
        // Fires every Missile_TIMER_TIMEOUT.
        private function Fire takes nothing returns nothing
            local integer i = remove[0]
            set remove[0] = 0
            loop
                exitwhen 0 == i
                if recycling[i] then
                    call TriggerRemoveCondition(CORE, condition[i])
                    set condition[i] = null
                    set active = active - 1
                endif
                set destroying[i] = false
                set recycling[i] = false
                set i = remove[i]
            endloop
           
            if 0 == active then
                call PauseTimer(TMR)
            else
                // Move all launched missiles.
                set Missile.temp = nextNode[0]
                set i = 0
                loop
                    exitwhen TriggerEvaluate(MOVE)
                    exitwhen i == 60// Moved over 8910 missiles, something buggy happened.
                    set i = i + 1   // This case is impossible, hence never happens. But if I'm wrong, which also never happens
                endloop             // then the map 100% crashes. i == 66 will prevent the game crash and Missile will start to
                                    // to debug itself over the next iterations.
           
                // Access all structs using module MissileStruct.
                static if DEBUG_MODE and LIBRARY_ErrorMesssage then
                    if not TriggerEvaluate(CORE) then
                        call ThrowWarning(true, "Missile", "Fire", "op limit", 0, /*
    */
    "You just ran into a op limit!
    The op limit protection of Missile is insufficient for your map.
    The code of the missile module can't run in one thread and must be splitted.
    If unsure make a post in the official 'The Hive Workshop' forum thread of Missile!"
    )
                    endif
                else
                    call TriggerEvaluate(CORE)
                endif
            endif
        endfunction
       
        // Conditionally starts the timer.
        private function StartPeriodic takes integer structId returns nothing
            if 0 == instances[structId] or destroying[structId] then            
                if destroying[structId] then
                    set recycling[structId] = false
                else
                    if 0 == active then
                        call TimerStart(TMR, Missile_TIMER_TIMEOUT, true, function Fire)
                    endif
                    set active = active + 1
                    set condition[structId] = TriggerAddCondition(CORE, expression[structId])
                endif
            endif
            set instances[structId] = instances[structId] + 1
        endfunction
       
        // Conditionally stops the timer in the next callback.
        private function StopPeriodic takes integer structId returns nothing
            set instances[structId] = instances[structId] - 1
            if 0 == instances[structId] and condition[structId] != null then
                if not destroying[structId] and not recycling[structId] then
                    set destroying[structId] = true
                    set recycling[structId] = true
                    set remove[structId] = remove[0]
                    set remove[0] = structId
                endif
            endif
        endfunction
       
        // Modules:
        // ========
        //
        // You want to place module MissileLaunch at the very top of your struct.
        module MissileLaunch
            static method launch takes Missile missile returns nothing
                static if LIBRARY_ErrorMessage then
                    debug call ThrowError(missile.launched, "thistype", "launch", "missile.launched", missile, "This missile was already launched before!")
                endif
                debug set missile.launched = true
                //
                call missileList[thistype.typeid].insertFront(missile)
                call StartPeriodic(thistype.typeid)
            endmethod
        endmodule
       
        module MissileTerminate
            // Called from missileIterate. "P" to avoid code collision.
            static method missileTerminateP takes Missile node returns nothing
                if node.allocated then
                    static if thistype.onRemove.exists then
                        static if Missile_WRITE_DELAYED_MISSILE_RECYCLING and RecycleBin.recycle.exists then
                            if thistype.onRemove(node) and GetUnitTypeId(node.dummy) == Missile_DUMMY_UNIT_ID then
                                call RecycleBin.recycle(node.dummy)
                                call node.nullBefore()
                            endif
                        else
                            call thistype.onRemove(node)
                        endif
                    endif
               
                    call node.terminate()
                    call StopPeriodic(thistype.typeid)
                endif
            endmethod
        endmodule
       
        // Allows you to inject missile in certain stages of the motion process.
        module MissileAction

    static if DEBUG_MODE then
        // Runs check during compile time.
        static if thistype.onMissile.exists then
            Error Message from library Missile in struct thistype !
            thistype.onMissile is a reserved name for Missile, once you implemented MissileStruct.
            thistype.onMissile is currently not supported by library Missile.
            Please delete or re-name that method.
        endif
    endif

        static if thistype.onItem.exists then
            private static method missileActionItem takes nothing returns nothing
                local item i = GetEnumItem()
                local Missile this = Missile.temp
                if this.allocated then
                    call SaveItemHandle(HASH, this, GetHandleId(i), i)
                    if thistype.onItem(this, i) then
                        call missileTerminateP(this)
                    endif
                endif
                set i = null
            endmethod
        endif
           
        static if thistype.onDestructable.exists then
            private static method missileActionDest takes nothing returns nothing
                local destructable d = GetEnumDestructable()
                local Missile this = Missile.temp
                if this.allocated then
                    call SaveDestructableHandle(HASH, this, GetHandleId(d), d)
                    if thistype.onDestructable(this, d) then
                        call missileTerminateP(this)
                    endif
                endif
                set d = null
            endmethod
        endif
       
            // Runs every Missile_TIMER_TIMEOUT for this struct.
            static method missileIterateP takes nothing returns boolean
                local Missile this = missileList[thistype.typeid].first
                local Missile node
                local real collideZ
                local boolean b
                local unit u
               
                loop
                    exitwhen 0 == this
                    set node = this.next// The linked list should not lose the next node.
                   
                    if this.wantDestroy then
                        call thistype.missileTerminateP(this)
                    else
                        if this.stackSize > 0 then
                            call this.updateStack()
                        endif
                       
                        // Runs unit collision.
                        static if thistype.onCollide.exists then
                            if this.allocated and 0. < this.collision then
                                set b = this.collisionType == Missile_COLLISION_TYPE_RECTANGLE  
                                if b then
                                    call this.groupEnumUnitsRectangle()
                                else
                                    call GroupEnumUnitsInRange(GROUP, this.x, this.y, this.collision + Missile_MAXIMUM_COLLISION_SIZE, null)
                                endif
                                loop
                                    set u = FirstOfGroup(GROUP)
                                    exitwhen u == null
                                    call GroupRemoveUnit(GROUP, u)
                                    if not HaveSavedHandle(HASH, this, GetHandleId(u)) then
                                        if IsUnitInRange(u, this.dummy, this.collision) or b then  
                                            // Eventually run z collision checks.
                                            static if Missile_USE_COLLISION_Z_FILTER then
                                                set collideZ = Missile_GetLocZ(GetUnitX(u), GetUnitY(u)) + GetUnitFlyHeight(u) - this.terrainZ
                                                if (collideZ + GetUnitBodySize(u) >= this.z - this.collisionZ) and (collideZ <= this.z + this.collisionZ) then
                                                    // Mark as hit.
                                                    call SaveUnitHandle(HASH, this, GetHandleId(u), u)
                                                    if thistype.onCollide(this, u) then
                                                        call thistype.missileTerminateP(this)
                                                        exitwhen true
                                                    endif
                                                endif
       
                                            else
                                                // Runs unit collision without z collision checks.
                                                call SaveUnitHandle(HASH, this, GetHandleId(u), u)
                                                if thistype.onCollide(this, u) then
                                                    call thistype.missileTerminateP(this)
                                                    exitwhen true
                                                endif
                                            endif
                                        endif                                    
                                    endif
                                endloop
                            endif
                        endif
                       
                        // Runs destructable collision.
                        static if thistype.onDestructable.exists then
                            // Check if the missile is not terminated.
                            if this.allocated and 0. < this.collision then
                                call this.checkDestCollision(function thistype.missileActionDest)
                            endif
                        endif
                       
                        // Runs item collision.
                        static if thistype.onItem.exists then
                            //  Check if the missile is not terminated.
                            if this.allocated and 0. < this.collision then
                                call this.checkItemCollision(function thistype.missileActionItem)
                            endif
                        endif
                   
                        // Runs when the destination is reached.
                        if this.recycle and this.allocated then
                            static if thistype.onFinish.exists then
                                if thistype.onFinish(this) then
                                    call thistype.missileTerminateP(this)
                                endif
                            else
                                call thistype.missileTerminateP(this)
                            endif
                        endif
                   
                        // Runs on terrian collision.
                        static if thistype.onTerrain.exists then
                            if this.allocated and 0. > this.z and thistype.onTerrain(this) then
                                call missileTerminateP(this)
                            endif
                        endif
                   
                        // Runs every Missile_TIMER_TIMEOUT.
                        static if thistype.onPeriod.exists then
                            if this.allocated and thistype.onPeriod(this) then
                                call missileTerminateP(this)
                            endif
                        endif
                    endif
                    set this = node
                endloop
               
                set u = null
                static if DEBUG_MODE and LIBRARY_ErrorMessage then
                    return true
                else
                    return false
                endif
            endmethod
        endmodule
       
        module MissileStruct
            implement MissileLaunch
            implement MissileTerminate
            implement MissileAction
           
            private static method onInit takes nothing returns nothing
                call MissileCreateCollection(thistype.typeid)
                call MissileCreateExpression(thistype.typeid, function thistype.missileIterateP)
            endmethod
        endmodule
       
        // Missile position:
        // =================
        //
        // Simple trigonometry.
        //! textmacro WRITE_MISSILE_POSITION_CODE
            struct MissilePosition extends array
                private static integer array recycler
                private static integer alloc = 0
               
                // Readonly members you can access.
                readonly real x
                readonly real y
                readonly real z
                readonly real angle
                readonly real distance
                readonly real square
                readonly real slope
                readonly real alpha
               
                // Creates an origin - impact link.
                private thistype ref
               
                private static method math takes thistype a, thistype b returns nothing
                    local real dx
                    local real dy
                    loop
                        set dx = b.x - a.x
                        set dy = b.y - a.y
                        set dx = dx*dx + dy*dy
                        set dy = SquareRoot(dx)
                        exitwhen dx != 0. and dy != 0.
                        set b.x = b.x + .01
                        set b.z = b.z - Missile_GetLocZ(b.x -.01, b.y) + Missile_GetLocZ(b.x, b.y)
                    endloop
                   
                    set a.square   = dx
                    set a.distance = dy
                    set a.angle    = Atan2(b.y - a.y, b.x - a.x)
                    set a.slope    = (b.z - a.z)/dy
                    set a.alpha    = Atan(a.slope)*bj_RADTODEG
                    // Set b.
                    if b.ref == a then
                        set b.angle     = a.angle + bj_PI
                        set b.distance  = dy
                        set b.slope     = -a.slope
                        set b.alpha     = -a.alpha
                        set b.square    = dx
                    endif
                endmethod
               
                static method link takes thistype a, thistype b returns nothing
                    set a.ref = b
                    set b.ref = a
                    call math(a, b)
                endmethod
       
                method move takes real toX, real toY, real toZ returns nothing
                    set x = toX
                    set y = toY
                    set z = toZ + Missile_GetLocZ(toX, toY)
                    if ref != this then
                        call math(this, ref)
                    endif
                endmethod
       
                method destroy takes nothing returns nothing
                    set recycler[this] = recycler[0]
                    set recycler[0]    = this
                endmethod
       
                static method create takes real x, real y, real z returns MissilePosition
                    local thistype this = recycler[0]
                     if 0 == this then
                        set alloc = alloc + 1
                        set this  = alloc
                    else
                        set recycler[0] = recycler[this]
                    endif
                    set ref = this
                    call move(x, y, z)
                    return this
                endmethod
       
            endstruct
        //! endtextmacro
       
        // Delayed dummy recycling:
        // ========================
        //
        // Ensures proper fx death animations.
        //! textmacro WRITE_MISSILE_RECYCLE_BIN takes DO_THIS, AFTER_TIME
        static if $DO_THIS$ then

            private struct RecycleBin extends array
                private static constant timer t = CreateTimer()
                private static integer max = 0
                private static unit array dummy
                private static real array time
         
                private static method onPeriodic takes nothing returns nothing
                    local integer dex = 0
                    loop
                        exitwhen dex == thistype.max
                        set thistype.time[dex] = thistype.time[dex] - 1
                        if 0 >= thistype.time[dex] then
                       
                            static if LIBRARY_MissileRecycler then
                                call RecycleMissile(thistype.dummy[dex])
                       
                            elseif Dummy.create.exists and LIBRARY_Dummy then
                                call Dummy[thistype.dummy[dex]].destroy()
                           
                            elseif LIBRARY_xedummy and xedummy.release.exists then
                                call xedummy.release(thistype.dummy[dex])
                       
                            else
                                call RemoveUnit(thistype.dummy[dex])
                            endif
                       
                            set thistype.dummy[dex]          = null
                            set thistype.max                 = thistype.max - 1
                            set thistype.dummy[dex]          = thistype.dummy[thistype.max]
                            set thistype.time[dex]           = thistype.time[thistype.max]
                            set thistype.dummy[thistype.max] = null
                            set dex                          = dex - 1
                       
                            if 0 == thistype.max then
                                call PauseTimer(thistype.t)
                            endif
                       
                        endif
                        set dex = dex + 1
                    endloop
                endmethod
       
                static method recycle takes unit toRecycle returns nothing
                    if 0 == thistype.max then
                        call TimerStart(thistype.t, 1., true, function thistype.onPeriodic)
                    endif
                    set thistype.dummy[max] = toRecycle
                    set thistype.time[max]  = $AFTER_TIME$ + TimerGetRemaining(thistype.t)
                    set thistype.max        = thistype.max + 1
                endmethod
       
            endstruct
        endif
        //! endtextmacro
       
    // The end!
    endlibrary


    Requirements

    Important: Missile requires basic knowledge about structs, hence it is not GUI-friendly at all.
    Furthermore in order to compile library Missile, you'll need JPNG.

    By default library Missile has no external requirements. This is intended by me, as I don't want to enforce you as map maker
    to import a specific i.e. dummy recycler just because of library Missile. That way Missile can be imported very easily into any map.


    Optional requirements

    Missile can use a few optional requirements ( JassHelper link ), once they exists in your map.
    Each optional requirement has been chosen carefully. It's recommended to consider using one of each block listed in the table below.

    Important: Using more than one requirement of each block has no benefit at all! It would be counterproductive for your map!

    Dummy recycler​
    Safety​
    Debugging​




    Creators and destructors

    A new Missile instance can be allocated via following static methods:
    Reveal Creator & Destructor API
    Code (vJASS):
    ////
    //
    // Available creators:
    // ===================
        //
        static method createEx takes unit missileDummy, real impactX, real impactY, real impactZ returns Missile
        //  • Core creator method.
        //  • May launches any unit.
        //  • Units of type Missile_DUMMY_UNIT_ID get recycled in the end.
           
        static method create takes real x, real y, real z, real angleInRadians, real distanceToTravel, real endZ returns Missile
        //  • Converts arguments to fit into createEx, then calls createEx.
       
        static method createXYZ takes real x, real y, real z, real impactX, real impactY, real impactZ returns Missile
        //  • Converts arguments to fit into createEx, then calls createEx.
               
        // Available destructors:
        // ======================
            //
            return true
            //  • Core destructor.
            //  • Returning true in any of the interface methods of the MissileStruct module
            //    will destroy that instance instantly.
               
            method destroy   takes nothing returns nothing
            //  • Destroys the missile during the next timer callback.
           
            method terminate takes nothing returns nothing
            //  • Destroys the missile instantly.
     
    Each struct allocator is discussed in detail in this tutorial.

    module MissileStruct

    In order to use Missile in a struct, simply implement
    Module MissileStruct
    into it.
    Reveal code demonstration
    Code (vJASS):

    scope HowToUse

        struct HowToUse
           
            // MissileStruct has to be implemented below all declared methods
            // For better understanding check: Declaration
            implement MissileStruct// Adds required code to struct HowToUse

        endstruct

    endscope
     
    For more information look into this tutorial.

    Static methods in your struct

    Once
    module MissileStruct
    is implemented, you can declare various static methods in that struct.
    Later the compiler will check, if these methods exist and write the required code into your struct.

    Each method returns boolean ( true/false )
    return true - destroy this Missile instance.​
    return false - keep on moving this Missile instance.​

    Reveal Available Interface For Structs
    Code (vJASS):
    ////
    //
    //  Interface in structs: ( Must implement module MissileStruct )
    //  =====================
        //
        //  • Write one, many or all of the static method below into your struct.
        //  • Missiles launched in this struct will run those methods, when their events fire.
        //
        //  • All of those static methods must return a boolean.
        //      a) return true  --> destroys the missile instance instantly.
        //      b) return false --> keep on flying.

        // Available static method:  
        // ========================
            //
            static method onCollide            takes Missile missile, unit hit returns boolean
            //  • Runs for units in collision range of a missile.

            static method onDestructable       takes Missile missile, destructable hit returns boolean
            //  • Runs for destructables in collision range of a missile.
            //  • Runs after onDestructableFilter ( if a filter is declared )

            static method onDestructableFilter takes nothing returns boolean
            //  • Runs before onDestructable as filter function.
            //  • Runs for destructables in collision range + Missile_MAX_COLLISION_RANGE.
            //  • Get the filter destructable via "GetFilterDestructable()"
            //  • Designed only for improving code read-ability.

            static method onItem               takes Missile missile, item hit returns boolean
            //  • Runs for items in collision range of a missile.
            //  • Runs after onItemFilter ( if a filter is declared )

            static method onDestructableFilter takes nothing returns boolean
            //  • Runs before onItem as filter function.
            //  • Runs for items in collision range + Missile_MAX_COLLISION_RANGE.
            //  • Get the filter item via "GetFilterItem()"
            //  • Designed only for improving code read-ability.            
               
            static method onTerrain takes Missile missile returns boolean
            //  • Runs when a missile collides with the terrain. ( Ground and cliffs )
               
            static method onFinish  takes Missile missile returns boolean
            //  • Runs only when a missile reaches it's destination.
            //  • However does not run, if a Missile is destroyed in another method.
               
            static method onPeriod  takes Missile missile returns boolean
            //  • Runs every Missile_TIMER_TIMEOUT seconds.

            static method onRemove takes Missile missile returns boolean
            //  • Runs when a missile is destroyed.
            //  • Unlike onFinish, onRemove will runs ALWAYS when a missile is destroyed!!!
            //  
            //  For onRemove the returned boolean has a unique meaning:
            //
            //  • Return true will recycle this missile delayed. ( only if WRITE_DELAYED_MISSILE_RECYCLING = true )
            //  • Return false will recycle this missile right away.
               
            static method launch takes Missile toLaunch returns nothing
            //  • Well ... Launches this Missile.
            //  • Missile "toLaunch" will behave as declared in the struct. ( static methods from above )


    Reveal code demonstration
    Code (vJASS):

    scope HowToUse

        struct HowToUse
           
            static method onCollide takes Missile missile, unit hit returns boolean
                if UnitAlive(hit) then
                    return true// Destroy this Missile instance
                endif
                return false// Keep on flying
            endmethod

            // MissileStruct has to be implemented below all declared methods
            // For better understanding check: Declaration
            implement MissileStruct// Adds required code to struct HowToUse

        endstruct

    endscope
     


    Missile members and methods

    Each Missile instance has fields you can set and / or read.
    Reveal Available Members and Methods
    Code (vJASS):
    ////
    //
    //  Fields you can set and read directly:
    //  =====================================
            //
            unit       source
            unit       target      // For homing missiles.
            real       distance    // Distance traveled.
            player     owner       // Pseudo owner for faster onCollide evaluation. The proper dummy owner remains PLAYER_NEUTRAL_PASSIVE.
            real       speed       // Vector lenght for missile movement in plane x / y. ( DOES NOT TAKE THE TIMER TIMEOUT IN ACCOUNT )
            real       acceleration
            real       damage
            integer    data        // For data transfer set and read data.  
            boolean    recycle     // Is automatically set to true, when a Missile reaches it's destination.
            real       turn        // Set a turn rate for a missile.
               
            // Neither collision nor collisionZ accept values below zero.
            real       collision   // Collision size in plane x / y.
            real       collisionZ  // Collision size in z - axis.
               
        // Fields you can only read:
        // =========================      
            //
            readonly boolean         allocated        
            readonly unit            dummy// The dummy unit of this missile.
           
            // Position members for you needs.
            readonly MissilePosition origin// Grants access to readonly members of MissilePosition,
            readonly MissilePosition impact// which are "x", "y", "z", "angle", "distance", "slope" and the pitch angle "alpha".
            readonly real            terrainZ
            readonly real            x
            readonly real            y
            readonly real            z
            readonly real            angle// Current angle in radians.

        // Method operators for set and read:
        // ==================================
            //
            method operator model= takes string modelFile returns nothing
            method operator model  takes nothing returns string
            //  • Adds an effect handle on a missile dummy to it's "origin".
            //  • You can read the file path.
            //  • For multiple effects access "this.dummy" in your struct.
               
            method operator scale= takes real value returns nothing
            method operator scale  takes nothing returns real
            //  • Set and read the scaling of the dummy unit.  
               
            method operator curve= takes real value returns nothing
            method operator curve  takes nothing returns real
            //  • Enables curved movement for your missile. ( Pass in radians, NOT degrees )
            //  • Do not pass in PI/2.
           
            method operator arc=   takes real value returns nothing
            method operator arc    takes nothing returns real
            //  • Enables arcing movement for your missile. ( Pass in radians, NOT degrees )
            //  • Do not pass in PI/2.
                           
        // Methods for missile movement:
        // =============================
            //
            method bounce           takes nothing returns nothing
            //  • Moves the MissilePosition "origin" to the current missile coordinates.
            //  • Resets the distance traveled to 0.
               
            method deflect          takes real tx, real ty returns nothing
            //  • Deflect the missile towards tx, ty. Then calls bounce.        
           
            method deflectEx        takes real tx, real ty, real tz returns nothing
            //  • Deflect the missile towards tx, ty, tz. Then calls bounce.
       
            method flightTime2Speed takes real duration returns nothing
            //  • Converts a fly time to a vector lenght for member "speed".
            //  • Does not take acceleration into account. ( Disclaimer )
           
            method setMovementSpeed takes real value returns nothing
            //  • Converts Warcraft III movement speed to a vector lenght for member "speed".
    Reveal code demonstration
    Code (vJASS):

    scope HowToUse

        struct HowToUse

            private static method onCollide takes Missile missile, unit hit returns boolean
                if UnitAlive(hit) and IsUnitEnemy(hit, missile.owner) then
                    call UnitDamageTarget(missile.source, hit, missile.damage, false, false, null, null, null)
                    return true
                endif
                return false
            endmethod

            // MissileStruct has to be implemented below all declared methods
            // For better understanding check: Declaration
            implement MissileStruct// Adds required code to struct HowToUse

            static method onCast takes nothing returns nothing
                local Missile m =  Missile.create(-505, -670, 50, 90*bj_DEGTORAD, 1000, 50)
                set m.source    = GetTriggerUnit()
                set m.speed     = 15.
                set m.model     = "Abilities\\Weapons\\Arrow\\ArrowMissile.mdl"
                set m.arc       = GetRandomReal(0, bj_PI/4)
                set m.curve     = GetRandomReal(-bj_PI/4, bj_PI/4)
                set m.owner     = GetTriggerPlayer()
                call thistype.launch(m)// Launch is implemented via module MissileStruct
            endmethod

        endstruct

    endscope
     


    Demo Code

    I attached a demo map, which demonstrates how to use Missile.

    Public resources using Missile.

    Disclaimer

    Known issues
    • parabolla function, makes speed setup hard for small distances.
    • Meteor like systems are hard to design with Missile, as x/y velocity of 0 is not allowed in the parabolla function.
    • Non-square destructables are difficult to detect, as it is not supported by Blizzard.
    • Destructables placed with a z offset or created via CreateDestructableZ will not be detected properly.
    • onMissile
      method is not supported. ( I'm on it )
    • Bad collision detection for high speed, while using a low collision member ( I'm on it )

    Development

    All versions from 1.4 to 1.5 of Missile seems to be stable and working. If you experience any bugs/error
    please report them in the thread. I'm going to fix them as soon as possible.

    To-do List:
    • Rectangle collision.

    Changelog:
    See comment #2
     
    Last edited: May 13, 2016
  2. Ezekiel12

    Ezekiel12

    Joined:
    Mar 13, 2012
    Messages:
    1,056
    Resources:
    0
    Resources:
    0
    If this is serious better call the thread and testmap "Missile 2.0" :).

    Anyways, do you have any benchmarks?
     
  3. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    Changelog

    Version 1.0 - Version 1.4
    • Release ( undocumentated )
    Version 1.4.1 ( 13.01.2016 )
    • Added filter so only units of type Missile_DUMMY_UNIT_ID will set their pitch angle via SetUnitAnimationIndex()
    Version 1.4.2 ( 14.01.2016 )
    • Added static method onItem and static method onItemFilter.
    • Optimized the code a bit
    • Fixed widget collision ( item and destructable ). It works now properly.
    • Better safety for removing nodes from the core trigger.
    • Added method flyTime2Speed to covert for example 2 seconds into the proper missile speed.
    Version 1.5 ( 16.01.2016 )
    • real speed
      does now accept also 0 and negative values.
      ---
    • real turn
      is working properly.
      ---
    • Filter functions for widget collision are now created in one array inside Missile and not in each struct.
      ---
    • Item and destructable collision are now much more methodologically sound.
      Therefore they are no longer optional toogles of Missile, but permanent enabled in Missile.
      ---
    • Widget collision is now handled via one global hashtable instead of a unit group array.
      This was inevitable for item and destructable collision.
      ---
    • createEx is again the main creator function. create and createXYZ are now wrappers to createEx.
      This slightly slows down create, but reduces overall code and speeds up createXYZ on the other hand.
      ---
    • added
      method setMovementSpeed takes real value returns nothing
      . Coverts movement speed to missile speed.
      ---
    • Debug options in DEBUG_MODE are better than ever.
      ---
    • Added method flyTime2Speed to covert for example 2 seconds into the proper missile speed.
      ---
    • I restructured the code to be more read-able.
      ---
    • The code documentation is now epic ( my opinion ).
    Add stress test can be found here ( link )
    Manual about collision types for missiles can be found here.

    Version 2.0Version 2.0.1
    • Hotfix. You're losing now the origin location when using target=
      That was important, because otherwise all pitch angle and z calculation go nuts.
    Version 2.0.2
    • Hotfix. Code was not compiling with library ErrorMessage, this is now fixed.
    Version 2.0.2.1
    • Corrected some grammar mistakes.
    • Optimized & shortened to code minimal ( 3 - 5 lines )
    • Not using WorldBounds or BoundSentinel makes Missile switch from SetUnitX/Y to SetUnitPosition ( safety first ).
    • flightTime2Speed does no longer crash the thread if the passed in value is 0.
    Version 2.0.2.2
    • Not longer uses SetUnitPosition in abscence of WorldBounds or BoundSentinel. Instead uses
      RectContainsCoords
      .
    Version 2.0.3
    • Improved the protection of internal linked list of the Missile core trigger, to not fail in very seldom corner cases.
    Version 2.1
    • Kicked out onDestructableFilter / onItemFilter from the Missile interface.
    • onItem / onDestructable are now even better and similar in mechanics to onCollide.
    Version 2.3
    • Added more solidity against an OP limit case.
    • Missile shouts at you with an error message if you run into an OP limit situation.
    Version 2.4
    • Fixed all flaws concerning target= ( hopefully )
    Version 2.4.1
    • Hotfix in MissilePosition ensuring to never hit an OP limit.
    Version 2.5
    • Previously enqueued, now new nodes are now pushed to the list of missiles to ensure better system stability.
    • Optimized widget collision a bit.
    • Removed collisionZ as stand-alone member. Considering the resolution of Warcraft III, it's fair enough to use one collision size for all three dimensions.
    • Missile motion runs now over a static unique list. It's faster and more methodologically sound than executing projectile motion per struct.
    • module MissileStruct has been split into module MissileLaunch, module MissileTerminate, module MissileAction, module MissileStruct.
      Nothing changes as module MissileStruct implements all, however you can now implement module MissileLaunch at the very top to prevent pseudo code generation.
    Version 2.5.1
    • Previously private, real prevX, prevY and prevZ are now read-only.
    • terminate() has now a build in double free safety, hence is always safe to use.
    • Optimized the missile motion loop as good as possible.
    • Missiles can no longer collide with themself.
    • Added safety to missile motion.
     
    Last edited: Mar 1, 2016
  4. Quilnez

    Quilnez

    Joined:
    Oct 12, 2011
    Messages:
    3,294
    Resources:
    37
    Icons:
    2
    Tools:
    1
    Maps:
    7
    Spells:
    21
    Tutorials:
    2
    JASS:
    4
    Resources:
    37
    End-user optional method
    Code (vJASS):
    static method isCollide takes real xyDiff, real zDiff returns boolean
    // xyDiff is distance between missile and the target
    // zDiff is difference between missile's and target's height z


    If the method exists, evaluate that method, if not, use that GetUnitBodySize.

    Using the method then I can choose to have box or spherical collision or anything using the passed data.
    Code (vJASS):
    // Box collision
    static method isCollide takes real xyDiff, real zDiff returns boolean
        return xyDiff < 100 and zDiff < 100
    endmethod

    or
    Code (vJASS):
    // Spherical collision
    static method isCollide takes real xyDiff, real zDiff returns boolean
        return xyDiff*xyDiff+zDiff*zDiff < 10000
    endmethod


    And ultimately, I can have my own value for collision sizes. :)


    onTerrain => onGround (just sounds better)
    createXY => createXYZ (?)


    Code (vJASS):

            // Maintain Dirac's API. ... Seriously this method is crap.
            static method createLoc takes AdvLoc originP, AdvLoc impactP returns thistype
                //! runtextmacro CREATE_MISSILE_DUMMY_UNIT("originP.x", "originP.y", "originP.z")
            endmethod

    You are not obligated to serve that ultimate crap dinner right?


    More things:
    They are non constant
    Code (vJASS):

            private integer             array   @INSTANCES@
            private TimerGroup32        array   @TIMER@
            private Missile             array   @STACK@

    Just that actually.


    Code (vJASS):

            static if LIBRARY_MissileRecycler then
                return createEx(GetRecycledMissile($X$, $Y$, $Z$, originP.angle*bj_RADTODEG), originP, impactP)
           
            elseif LIBRARY_Dummy and Dummy.create.exists then
                return createEx(Dummy.create($X$, $Y$, originP.angle*bj_RADTODEG).unit, originP, impactP)
           
            else
                return createEx(Missile.newMissileUnit($X$, $Y$, originP.angle*bj_RADTODEG), originP, impactP)
            endif

    I didn't know elseif works for static if, does it? :/
     
  5. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    - I like the isCollide idea. I'll add it as soon as possible. You wish to run that when a Missile is actually in collision range or on every loop ?
    There are two members for collision which is collision and collsionZ.

    - Yeah maybe onGround, onSurface, ... sounds better. Basically a check which can also be done in onPeriod. I will think about the best name.

    - Yes createXYZ would be more precise.

    - I keep createLoc, doesn't hurt too much.... sounds like location??...
    some people maybe used it, so they don't have to change their code after c'n'p the new Missile library.

    - Why should they be constant? I don't think you can assign a value to a constant variable onInit.

    - Yes I tested the elseif behaviour with static ifs.
     
  6. edo494

    edo494

    Joined:
    Apr 16, 2012
    Messages:
    3,846
    Resources:
    5
    Spells:
    1
    JASS:
    4
    Resources:
    5
    by the current standard we use, all caps names are reserved for constant variables
     
  7. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    Ah I see. Thanks for the explanation.
    I will change it, anyway you can't access these 3 so it's just a
    read-ability flaw.
     
  8. Quilnez

    Quilnez

    Joined:
    Oct 12, 2011
    Messages:
    3,294
    Resources:
    37
    Icons:
    2
    Tools:
    1
    Maps:
    7
    Spells:
    21
    Tutorials:
    2
    JASS:
    4
    Resources:
    37
    Evaluating the method only if there happens collision will just causing a couple more of evaluations (2x collision checks). And moreover, it bounds the user to only have maximum collision size of that default value. So, no, you better run it on every iterated widget on every tick.

    No, I meant, capitalized names are for constant only, whereas those variables are not constant but you capitalized them all.
     
  9. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    isCollide can only run, if there is an unit set to target.

    GetUnitBodySize is there to figure out the z height of a unit from toe to head,
    otherwise
    collisionZ
    does not work properly. I think there is no data for exact values,
    you have to make up your own (test to get appropriate values)
    Furthermore you may want to have different value for different units (mountain giant, peon, ...)
    ... Or maybe have scaled units in your map.

    Update 1.1
    - changed XY to XYZ
    - changed variables names according to the JPAG. --> camelCase.

    Funny fact:
    KillUnit
    on units having locust, will make that unit be considered by GroupEnumUnit functions.
    That's why I'm using ExecuteFunc and TriggerSleepAction to remove dummy units.

    I agree that ground is a much more used word than terrain in english language.
    However in wc3/editor/forum we use words like terrain board, terrain pallete, terraining, ....
    that's why I think
    onTerrain
    is an adequate name to describe that type of collision.

    There are some disclaimers with onDestructable.
    • does not work good for destructables created via CreateDestructableZ
    • does not work for destructables with no square pathing block (gates)
    --> as destructables are not as good supported by natives like units,
    the only way to evaluate a destructable collision is to check the
    distance between the missile and widget. However this distance is always based on
    the center of that widget and center of the missile.
    If really required, you could detect a gate in case you know it's facing angle and the size of each pathing block (64*64).
    --> using is Missile in RectAngle()
    Another way would be to normalize coordinates, store them into a hashtable and define a collision there ( takes time).
    Basically you check for the collision per tile.
     
    Last edited: May 6, 2015
  10. Quilnez

    Quilnez

    Joined:
    Oct 12, 2011
    Messages:
    3,294
    Resources:
    37
    Icons:
    2
    Tools:
    1
    Maps:
    7
    Spells:
    21
    Tutorials:
    2
    JASS:
    4
    Resources:
    37
    I think I understood the way you deal with collision a bit wrong. I thought you always set it to somekind of default value, but then I see you are allowing user to modify the collision size anytime without limitation, so there is no really something called maximum size. My bad.

    So then, you can evaluate the method whenever a unit is in range (to every first of group).

    if thistype.isCollide(range between missile and fog, Abs(missile z - fog z)) and thistype.onCollide(this, fog) then
    ...

    Hm? Are you sure? Why so?

    You can evaluate it anytime if one or some units are in range from missile. Must be somewhere around this part:
    Code (vJASS):

                                        call GroupEnumUnitsInRange(bj_lastCreatedGroup, this.x, this.y, this.collision + Missile_MAXIMUM_COLLISION_SIZE, null)
                                        loop
                                            set u = FirstOfGroup(bj_lastCreatedGroup)
                                            exitwhen u == null
                                            call GroupRemoveUnit(bj_lastCreatedGroup, u)
                                            if IsUnitInRange(u, this.dummy, this.collision) then
                                                set collideZ = Missile_GetLocZ(GetUnitX(u), GetUnitY(u)) + GetUnitFlyHeight(u) - Missile_GetLocZ(this.x, this.y)
                                                if (collideZ + GetUnitBodySize(u) >= this.z - this.collisionZ) and (collideZ <= this.z + this.collisionZ) then
                                                   if not (IsUnitInGroup(u, this.unitsHit)) and (u != this.target) and thistype.onCollide(this, u) then
                                                       
     
  11. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    1. onDestructableFilter was not recognized, because of a missing .exists
    fixed.

    2. Add a demo for detecting destructable with non square collision. However this method is not recommened.
    Best would be to store these coordinated on normalizedXY values in a hashtable and check if the missile is within such a box.

    Currently Missiles can't jump on one point, due to a flaw in Dirac's AdvLoc.
    He didn't cover the case that two locations can have the same coordinates and therefore divides with 0.
    You can work around this by changing x or y or one AdvLoc by a very small value.

    Update:

    I found two critical issues and will fix them as soon as possible
    - Double free error, if using onDestructable and onCollide, while both return true during the same loop.
    - recycle never runs, if onTerrain is declared and returns true before.

    So I have to reconsider the priority of each method (which should run first)
     
    Last edited: May 7, 2015
  12. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    I updated the code, because I found another mistake in the original Missile which is now fixed.
    • Double Free Protection, when using various combinations of missile methods in one struct.
    • Theoretically you can now shoot any unit as Missile, it will then not be recycled. Just unliked once the Missile instance gets destroyed
    • Collision should now work even with curved Missiles, I will write a small snippet to check hit boxes with lightnings to see if it's working as intended. :)
     
  13. msongyboi

    msongyboi

    Joined:
    Feb 3, 2013
    Messages:
    272
    Resources:
    4
    Spells:
    4
    Resources:
    4
    Code (vJASS):
    // bpower
    set m.speed = 15.625
    set m.arc = .25
    call launch(m)

    // vexorian
    call .launch(500, .25)


    [​IMG]

    your pitch and arc calculation are a little weird..
    i've tweaked with your demo a bit, and the pitch only gets considered when the arc becomes extreme. like +.5 arc or something

    yours is the first, where the pitch is straight and vex is the one where the pitch is dynamic and smooth
    final note, very nice demo! :>
     
    Last edited: May 14, 2015
  14. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    I took over the pitch calculation from dirac. I will look into it.
    There are anyway still some issues to fix.

    Thanks :)
     
  15. Zwiebelchen

    Zwiebelchen

    Joined:
    Sep 17, 2009
    Messages:
    6,804
    Resources:
    12
    Models:
    5
    Maps:
    1
    Spells:
    1
    Tutorials:
    1
    JASS:
    4
    Resources:
    12
    Thanks for all your work on missile!

    Finally a bug-free version of missile is there for the masses.

    I really wonder why we didn't get this before 2015, with all those great coders around here... maybe because all were busy coding stuff nobody needs? Dat Hive-style... ;)

    Good job on keeping the API compatible to Dirac's Missile.
    AdvLoc is a pain in the ass and I'd definitely support getting rid of it, but unfortunately, it would require to change all spells using the old missile to be changed. And that is probably a no-go. We want to encourage people to use this with minimal extra effort.

    Didn't you find a more elegant way? Both ExecuteFunc and TriggerSleepAction are terrible. ShowUnit(false) doesn't work either?
    And why actually kill the missile? Just play the death animation and then remove it.
     
  16. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    I didn't experiment so much with: how to remove a non recycle-able missile in the best way.
    I though most people use either Dummy recycler, Dummy or xe(not supported since:( )

    - Just removing will kill the death animation ( dirac did this)
    - KillUnit will make it beeing enumerated by GroupEnumUnits
    - AddTimedLife( I didn't try that one )
    - Keep on iterating without running extra code, until the death animation is over ( could be best solution )
    - deallocate + ExecuteFunc + TriggerSleepAction + RemoveUnit ( I did this )

    There are still some issues in this version of Missile:

    - pitch angle thing
    - correct order of how the method are called. (onCollide before onDestructable? .. etc)
    - onDestructable, onCollide do not run on the last tick ( onFinsh ) ingame that can look really strange.
    - i didn't look into deflect and bounce yet, maybe they need a fix aswell

    These are small things but I will try to fix them aswell

    Edit:

    I wrote a recycler for destroyed dummy units. I think it's the best solution.
     
    Last edited: May 15, 2015
  17. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    TO DO:

    - RecycleBin for delayed dummy removal

    - Integrate more dummy recycling resources.
    --> Currently supported: Dummy, DummyRecycler, xedummy
    --> write if you wish your system to be integrated.
    --> Requirements: public approved, angle sorting

    - Correct pitching angle
    --> Pitch angles may freak out over uneven terrain (I'm on it)

    - Best method order for the MissileStruct
    --> Currently there are some flaws

    - Better destructable detection
    --> Quite hard, as destructables are shitty supported by blizzard

    - Jump in place to allow for example Meteors
    --> Here i have to work around AdvLoc and Loc from dirac ...

    - Make Missile Popular
    xe has the same behaviour on uneven terrain

    arc should take values in range of -PI/2 and PI/2. Everything in Missile works with radians
     
    Last edited: May 15, 2015
  18. Sapeur-Goblin

    Sapeur-Goblin

    Joined:
    Jun 25, 2011
    Messages:
    35
    Resources:
    0
    Resources:
    0
    How does the missile react when the target unit is teleported?
     
    Last edited: May 16, 2015
  19. BPower

    BPower

    Joined:
    Mar 18, 2012
    Messages:
    1,709
    Resources:
    21
    Spells:
    15
    Tutorials:
    1
    JASS:
    5
    Resources:
    21
    It will start to follow the target to its new position.
    target= make a Missile a homing missile.

    I will add a demo for that aswell soon.

    EDIT:

    First of all I will remove Loc and AdvLoc from Missile, just because they suck.
    Sorry for those who create Missiles via Missile.createLoc/Ex(unit, loc1, loc2)
    It breaks the thread, if distance between two Locs is 0. (Can happen)
    I will simply integrate a small MissilePosition struct into the Missile library.
    Don't think I'm not a fan of high modularity ... modules, macros, sharing code all over a map. But these two
    finally make more trouble than they help.

    I added the options to set speed via fly duration. The function is not working properly yet when
    you also add an acceleration, but I will fix that soon.

    I would like to change module MissileStruct in that way, that ...
    - onCollide
    - onDestructable/Filter
    ... are called even when this.recycle is set to true. Dirac did not call onCollide in this case.

    Quick variable/case explanation:
    Missile(this).recycle is set to true, when a missiles fly distance is bigger or equal
    to the total distance it should fly. Basically on the tick it finishes its course.
    Since Missile works with a 1/32 timeout and a (constant) speed (not vector), it is
    inaccurate to not call onCollide and onDestructable on the last tick.

    That is why I want to move onCollide and onDestructable to the top (below wantDestroy) and call them
    before onFinish is called. onPeriod and onTerrain still stay exluded if recycle is set to true.

    onPeriod is not important in an onFinish case and onTerrain most times will be true in case of onFinish....

    I always wish to write an algorithm to easily detect non square destructables.... :)
     
    Last edited: May 17, 2015
  20. Zwiebelchen

    Zwiebelchen

    Joined:
    Sep 17, 2009
    Messages:
    6,804
    Resources:
    12
    Models:
    5
    Maps:
    1
    Spells:
    1
    Tutorials:
    1
    JASS:
    4
    Resources:
    12
    Try not to convolute the system too much by adding too much new variables and methods. The cool thing about the original Missile was that it's API was rather basic.

    After thinking about this again, actually, I prefer Dirac's implementation of instant removal of the missile.

    Instant removal without death animation gives us the power to customize the death animation of our missile. What if I want my shadowbolt spell not to use the default death animation of deathcoil?
    Thinking about timed removal is a waste of effort. People can just play a special effect onCollide or onDestroy, like they did with the original system.


    Beware of the destructable thing, though: make the whole destructable add-in optional. I assume that most people won't ever use the destructable feature, so make sure it doesn't slow the system down by adding enough static ifs.


    You have my vote for removing AdvLoc, though. I also think that fewer dependencies are better.
    Actually, I would remove CTL aswell. CTL kind of fixes a problem that never existed in the first place.