library SW initializer Ini{
         //ВСПОМОГАТЕЛЬНОЕ
         define{
          private AngBetP(x,y,x1,y1) = Atan2(y1-y,x1-x)
          private Sqrt(x) = SquareRoot(x)
          private VAng(x,y) = Atan2(y,x)
          private GetX(u) = GetWidgetX(u)
          private GetY(u) = GetWidgetY(u)
          private GetHp(u) = GetWidgetLife(u)
          //Для польз. функций:
          private LD=Dummy[LastDummy]
          //с setdef
          private SET(x)
          private int = integer
          private void = nothing
          private bool = boolean
          private break = exitwhen true
         }

         private real Sqr(real x){
          return x*x
         }
                 
         private real Dist(real x, real y, real x1, real y1){
          return Sqrt(Sqr(x-x1)+Sqr(y-y1))
         }
                 
         private real VLen(real x, real y){
          return Sqrt(Sqr(x)+Sqr(y))
         }
                 
         private real Min(real x, real y){
          if(x<y){return x}else{return y}
         }
                 
         private real Abs(real x){
          if(x<0){return -x}else{return x}
         }
                 
         //ОБЬЯВЛЕНИЕ
         private struct spell{
          int abilId,dummy
          real spd,r,dmg1,dmg2,dist,startDist
          string startFunc,loopFunc,attackFunc,endFunc
          bool stoppable
         }

         private struct shell{
          real SpdX,SpdY,R,Hp
          unit u, caster//для пользователя
          int n, abilNum, Dist
          player owner
          real speed(){
           return Sqrt(Sqr(this.SpdX)+Sqr(this.SpdY))
          }
          bool stoppable
         }
                 
         globals
          private group ForLoop=CreateGroup()
          private    spell Spell[100]
          private    int SpellsNum=0
          private    shell Dummy[300]
          private    int DummyNum=0
          //Использует только для крипления структуры к скиллу
          private    hashtable Hash=InitHashtable()
          private    trigger CastTrg=CreateTrigger()
          private timer Timer=CreateTimer()
          //Номер дамми для передачи в польз. функции
          private int LastDummy
          //Последний атакованный юнит
          private unit AttackedUnit
          //НАСТРОЙКИ
          public real MIN_HP=4
          public real TIMEOUT=0.03
         endglobals
         //==============================================================
         //ПОЛЬЗОВАТЕЛЬСКИЕ ФУНКЦИИ
         public real GetSpeed(){
          return Sqrt(Sqr(LD.SpdX)+Sqr(LD.SpdY))
         }
                 
         public real GetAngle(){
          return  Atan2(LD.SpdY,LD.SpdX)
         }
                 
         public void SetSpeed(real spd){
          real ang=GetAngle()
          LD.SpdX=spd*Cos(ang)
          LD.SpdY=spd*Sin(ang)
         }
                 
         public void SetAngle(real ang){
          real spd=GetSpeed()
          LD.SpdX=spd*Cos(ang)
          LD.SpdY=spd*Sin(ang)
         }
                 
         public unit GetDummy(){
          return LD.u
         }
                 
         public unit GetCaster(){
          return LD.caster
         }
                 
         public void SetDist(int x){
          LD.Dist=x
         }
                 
         public int GetDist(){
          return LD.Dist
         }
                 
         public unit GetAttackedUnit(){
          return AttackedUnit
         }
                 
         //создание остальных Get и Set функций
         define private ADD(X) = {
          public real  Get##X(){
           return Dummy[LastDummy].X
          }
          public void  Set##X(real x){
           Dummy[LastDummy].X = x
          }
         }
         ADD(SpdX)
         ADD(SpdY)
         ADD(R)
         ADD(Hp)
                 
         public void AddSpell(int abilId, int dummy, real spd, real r, real dmg1, real dmg2, real dist, real startDist, bool stoppable, string startFunc, string loopFunc, string attackFunc, string endFunc){
          SpellsNum++
          Spell[SpellsNum]=spell.create()
          setdef SET(x) = Spell[SpellsNum].x=x
          SET(abilId)
          SET(dummy)
          SET(spd)
          SET(r)
          SET(dmg1)
          SET(dmg2)
          SET(dist)
          SET(startDist)
          SET(stoppable)
          SET(startFunc)
          SET(attackFunc)
          SET(loopFunc)
          SET(endFunc)
          SaveInteger(Hash,abilId,0,SpellsNum)
         }
         //СИСТЕМА
                 
         private void DelDummy(int i){
          DummyNum--
          define private s=Dummy[i]
          RemoveUnit(s.u)           
          Dummy[DummyNum].n=i
          Dummy[i]=Dummy[DummyNum]
          //Dummy[DummyNum].destroy()
         }
                 
         private void Loop(){
          define{
           private D1 = Dummy[i]
           private D2 = Dummy[j]
           private end = {
            ExecuteFunc(Spell[Dummy[i].abilNum].endFunc)
            DelDummy(i)
            i--
           }
          }
          for(int i=0;i<DummyNum;i++){
           bool ok=true
           real min
           LastDummy=i
           D1.Dist--
           SetUnitPosition(D1.u,GetX(D1.u)+D1.SpdX,GetY(D1.u)+D1.SpdY)
           if(i!=DummyNum-1){
            for(int j=i+1;j<DummyNum;j++){
             if((IsPlayerEnemy(D2.owner,D1.owner))&&(Dist(GetX(D1.u),GetY(D1.u),GetX(D2.u),GetY(D2.u))<=D1.R+D2.R+D2.speed())){
              min=Min(D1.Hp,D2.Hp)
              D1.Hp-=min
              D2.Hp-=min
              if(D2.Hp<MIN_HP){DelDummy(j)}
              //конец скилла при столкновении
              if(D1.Hp<MIN_HP){
               end
               ok=false
               break
              }
             }
            }
           }
           if(ok){
            ExecuteFunc(Spell[D1.abilNum].loopFunc)
            GroupEnumUnitsInRange(ForLoop,GetX(D1.u),GetY(D1.u),D1.R,null)
            unit u
            loop
             u=FirstOfGroup(ForLoop)
             exitwhen u==null
             if IsUnitEnemy(u,D1.owner){
              if(D1.stoppable){
               min=Min(D1.Hp,GetHp(u))
               D1.Hp-=min
              }else{min=D1.Hp}
              UnitDamageTarget(D1.u,u,min,false,false,ATTACK_TYPE_MAGIC,DAMAGE_TYPE_MAGIC,WEAPON_TYPE_WHOKNOWS)
              AttackedUnit=u
              ExecuteFunc(Spell[D1.abilNum].attackFunc)
              if(D1.Hp==0){
               //конец скилла при попадении
               end
               ok=false
               GroupClear(ForLoop)
               break
              }
             }
             GroupRemoveUnit(ForLoop,u)
            endloop
            //конец скилла по расстоянию
            if((ok)&&(D1.Dist<1)){end}
           }
          }
          if(DummyNum==0){
           PauseTimer(Timer)
          }
          //BJDebugMsg(I2S(DummyNum))
         }
                 
         private void AddDummy(int i, unit u, int lvl, real tarX, real tarY){
          Dummy[DummyNum]=shell.create()
          define{         
           private sp = Spell[i]
           private D = Dummy[DummyNum]
          }
          real x=GetUnitX(u), y=GetUnitY(u);
          real ang=AngBetP(x,y,tarX,tarY)
          D.stoppable=sp.stoppable
          D.owner=GetOwningPlayer(u)
          D.abilNum=i
          D.caster=u
          D.u=CreateUnit(D.owner,sp.dummy,x+(Cos(ang)*sp.startDist),y+(Sin(ang)*sp.startDist),ang*bj_RADTODEG)
          D.SpdX=sp.spd*Cos(ang)
          D.SpdY=sp.spd*Sin(ang)
          D.R=sp.r
          D.Hp=sp.dmg1+sp.dmg2*lvl//
          D.Dist=R2I(sp.dist/D.speed())
          Dummy[DummyNum].n=DummyNum
          if(DummyNum==0){
           TimerStart(Timer,TIMEOUT,true,function Loop)
          }
          LastDummy=DummyNum
          ExecuteFunc(sp.startFunc)
          u=null
          DummyNum++
         }
                 
         private void Cast(){
          int i=LoadInteger(Hash,GetSpellAbilityId(),0)
          if(i!=0){
           AddDummy(i,GetTriggerUnit(),GetUnitAbilityLevel(GetTriggerUnit(),GetSpellAbilityId()),GetSpellTargetX(),GetSpellTargetY())
          }
         }
                 
         public void EmulSpell(int abilId, unit caster, int level, real tarX, real tarY){
          int i=LoadInteger(Hash,abilId,0)
          if(i!=0){
           AddDummy(i,caster, level, tarX,tarY)
          }
         }
                 
         private void Ini(){
          #for i(0,15)         
           TriggerRegisterPlayerUnitEvent(CastTrg, Player(i),EVENT_PLAYER_UNIT_SPELL_CAST,null)
          #endfor
          TriggerAddAction( CastTrg, function Cast )
         }
}