Request spell that contain timer

[8uY_YoU]

I want spell that using timer like Damage over time spell, Dashing spell, Projectile spell, or other

Because i want to learn it and make my own custom spell

I have looked some spell tutorial map that contain this, but i still don't understand because some comment of that spell only explain "how to copy this spell to your map?"

Can you make me one or give me a link to a thread that useful for me?

Also please add comment for every line of the code if you want to making one!

 

[8uY_YoU]

Bump

 

[Viikuna]

Ill make you a simple Dash.

edit. You want some image trail stuff for it, or just a simple dash with all basic timer and unit moving stuff?

Here it is. Its pretty quikcly made, but I tried to add some comments.

Ask if you dont understand something.

scope Dash initializer init

globals

  private constant integer  SPELL_ABILITY_ID      =      'Dash' 
  private constant real     TIMER_TIMEOUT         =      .025
  
  private constant real     MAX_DASHING_RANGE     =      1500. 
  private constant real     COLLINSION_SIZE       =      75.
  
  private constant real     INITIAL_VELOCITY      =      300.
  private constant real     MAX_VELOCITY          =      1500.
  private constant real     ACCELERATION          =      50.
  
  private constant string   DAMAGE_EFFECT_PATH    =      "Objects\\Spawnmodels\\Orc\\Orcblood\\BattrollBlood.mdl"
  private constant integer  RUN_ANIMATION_INDEX   =      7
  
endglobals

private constant function SPELL_DAMAGE takes integer level returns real
    return level * 25. + 25.
endfunction



// private struct image

    // If you want to create some image  trail stuff, 
    // you can have a own struct for each image and
    // use image array inside that ability struct

// endstruct

private struct ability

     // image array Trail[10]
     
     
     
     // This variable is used to store our dashing unit
     
     unit unit
     
     // These variables hold some reals that are needed for our 
     // mathematical calculations
     
     real x
     real y
     real sin
     real cos
     real velocity
     real acceleration
     real maxvelocity
     real distance
     
     // Real damage tells us how much damage spell does
     // Group damaged is used to store those units who 
     // have already been damaged by spell, 
     // so we dont damage them more than once
    
     real damage
     group damaged
     

     // These are important variables. 
     // They are for making a MUI timer spell.
     
     // We basicly have all the active spell instances
     // in an array called 'array'
     
     // Then we loop trought that array and do actions for all those 
     // dashing units.
     
     // This uses some basic array sorting.
     
     static ability array array
     static timer timer=CreateTimer()
     static integer Count=0
     
     // These are for grouping units who come in our way:
     
     static filterfunc filter
     static group group=CreateGroup()
     static ability temp
     
     
     // This method is used to create make some unti dash
     // it creates a new ability struct instance 
     // and starts activates our systems
    
     
     static method create takes unit dasher, location target returns ability
         // allocate new ability instance:
        
         local ability this=ability.allocate()
         
         // set variables and calculate math stuff:
         
         local real x=GetUnitX(dasher)
         local real y=GetUnitY(dasher)
         local real dx=GetLocationX(target)-x
         local real dy=GetLocationY(target)-y
         local real angle=Atan2(dy,dx)
         call RemoveLocation(target)
         set .x=x
         set .y=y
         set .cos=Cos(angle)
         set .sin=Sin(angle)
         set .distance=SquareRoot(dx*dx+dy*dy)
         if .distance>MAX_DASHING_RANGE then
             set .distance=MAX_DASHING_RANGE
         endif
         set .unit=dasher
         set .damage=SPELL_DAMAGE(GetUnitAbilityLevel(dasher,SPELL_ABILITY_ID))
         set .velocity= INITIAL_VELOCITY * TIMER_TIMEOUT
         set .maxvelocity = MAX_VELOCITY * TIMER_TIMEOUT
         set .acceleration = ACCELERATION * TIMER_TIMEOUT
         
         // we should maybe pause our dasher for dash duration and set
         // its animation to run
         call IssueImmediateOrder(dasher,"stop")
         call SetUnitPathing(dasher,false)
         call PauseUnit(dasher,true)
         call SetUnitTimeScale(dasher,3.)
         call SetUnitAnimationByIndex(dasher,RUN_ANIMATION_INDEX)
         
         // if our damaged group doesnt exist yet we create it:
         // We might have damaged group already, 
         // because struct ids are recycled
         
         if .damaged==null then
            set .damaged=CreateGroup()
         else
            call GroupClear(.damaged)
         endif
         
         // Now we set this struct to an array, 
         // so that our timer can take care of dashing
         
         // if there is no dashes going on, we start timer
         if .Count==0 then
             call TimerStart(.timer,TIMER_TIMEOUT,true,function ability.Periodic)
         endif
         set .array[.Count]=this
         set .Count=.Count+1
         
         // we must return our struct instance,
         // because thats how struct syntax is
         return this
     endmethod
     
     
     private static method Periodic takes nothing returns nothing
          
          // This is our main method
          // It is called by the timer, every TIMEOUT seconds.
          // We use loop to do the actions for all ability instances in array 
          
          local integer i=0
          local ability this
          loop
            exitwhen i>=.Count
            set this=.array<i>
            
            // Here we do some math and move our dashing guy:
            
            set .x=.x+.velocity*.cos
            set .y=.y+.velocity*.sin
            set .distance=.distance-.velocity
            if .velocity&lt;.maxvelocity then
                set .velocity=.velocity+.acceleration
            endif
            
            // some SafeX&amp;Y would be nice, 
            // so unit cant dash away from map and crash the game
            
            call SetUnitX(.unit,.x)
            call SetUnitY(.unit,.y)
            
            // Here we damage all the enemies who get in our way:
            // Check method DamageTarget
            set .temp=this
            call GroupEnumUnitsInRange(.group,.x,.y,COLLINSION_SIZE,.filter)
            
            
            // If there is no distance left between dasher and the target,
            // we will end the spell and sort the array, so that there will be
            // no empty spots in it and we can safely continue our looping
            // ( Or pause the timer if there is no dashers dashing ) 
            if .distance&lt;=0.0 then
            
                // unpause and reset animation
                call PauseUnit(.unit,false)
                call SetUnitTimeScale(.unit,1.)
                call SetUnitAnimation(.unit,&quot;stand&quot;)
                call SetUnitPathing(.unit,true)
                
                // destroy struct and sort array
                call .destroy()
                set .Count=.Count-1
                if .Count&gt;0 then
                    set .array<i>=.array[.Count]
                    set i=i-1
                else
                    call PauseTimer(.timer)
                endif
            endif
            set i=i+1
            
        endloop
     endmethod
     
     private static method DamageTarget takes nothing returns boolean
         
         // When we call GroupEnum with this filter function, it will damage 
         // all those units who match our conditions.
         // We use .temp to pass the correct ability instance to this filter
         
         local unit u=GetFilterUnit()
         if not IsUnitInGroup(u,.temp.damaged) and GetWidgetLife(u)&gt;.405 and IsUnitEnemy(.temp.unit,GetOwningPlayer(u)) then
             call GroupAddUnit(.temp.damaged,u)
             call UnitDamageTarget(.temp.unit,u,.temp.damage,false,false,ATTACK_TYPE_NORMAL,DAMAGE_TYPE_MAGIC,null)
             call DestroyEffect(AddSpecialEffectTarget(DAMAGE_EFFECT_PATH,u,&quot;chest&quot;))
         endif
         set u=null
         return false
     endmethod
     

     static method onInit takes nothing returns nothing
     
 // onInit is called at map Init, so we use it to create our filter
         
         set .filter=Filter(function ability.DamageTarget)
     endmethod
     
endstruct


private function SpellEffect takes nothing returns boolean
    
    // Here we check if casted spell is our dash spell
    // If it is, we create a new ability instance 
    // and the spell code will start doing its actions
    
    local location l
    if GetSpellAbilityId()==SPELL_ABILITY_ID then
        set l=GetSpellTargetLoc()
        call ability.create(GetTriggerUnit(),l)
        call RemoveLocation(l)
        set l=null
    endif
    return false
endfunction

private function init takes nothing returns nothing
    
    // Here we create a trigger, which will detect spell casting
    // and then call function Spell Effect
    
    local trigger t=CreateTrigger()
    call TriggerRegisterAnyUnitEventBJ(t,EVENT_PLAYER_UNIT_SPELL_EFFECT)
    call TriggerAddCondition(t, Condition(function SpellEffect))
endfunction

endscope</i></i>

 

[8uY_YoU]

Nope Viikuna,
It is enough to be learned

+Rep