library UserData 
{

    hashtable HashTable = InitHashtable()
    private int count = 0
    private int slot_count = 0
    private int array buff_slots

    void SetUserData(handle h, int val)
    {
        SaveInteger(HashTable,GetHandleId(h),0,val)
        SaveBoolean(HashTable,GetHandleId(h),1,false)
    }
    
    void SetStaticUserData(handle h, int val)
    {
        SaveInteger(HashTable,GetHandleId(h),0,val)
        SaveBoolean(HashTable,GetHandleId(h),1,true)
        count++;
    }

    int GetUserData(handle h)
    {
        return LoadInteger(HashTable,GetHandleId(h),0)
    }    
    
    void FlushUserData(handle h)
    {
        #if Debug 
            LogAdd("FlushUserData func использовано: " + I2S(slot_count))
        #endif
        if (LoadBoolean(HashTable,GetHandleId(h),1) == false)
        {
            slot_count++
            buff_slots[slot_count] = GetUserData(h)
            FlushChildHashtable(HashTable,GetHandleId(h))
        }
    }
    
    void RemoveUnitEx(unit u)
    {
        RemoveUnit(u)
        FlushUserData(u)
    }
    
    int GetNewIndex()
    {
        if slot_count > 0
        {
            slot_count--
            return buff_slots[slot_count+1]
        }
        else
        {
            count++
            return count
        }
        return 0
    }
    
    int GetIndex(handle u)
    {
        if GetUserData(u) == 0
        {
            if slot_count > 0
            {
                if slot_count > 8000
                {
                    BJDebugMsg("Внимание! Скоро всему будет пиздец!!!")
                }
                SetUserData(u,buff_slots[slot_count])
                slot_count--
            }
            else
            {
                count++
                SetUserData(u,count)
            }
        }
        return GetUserData(u)
    }    
}

library MoveDummyToCoord uses UserData
{        
    #define private TimerAction(onPeriod, onEnd) = 
    {
        vblock
        {
            timer t = GetExpiredTimer();
            int index = GetUserData(t);
            unit TriggerUnit = PandoraDB_Dummy[index];
            float TriggerX = GetUnitX(TriggerUnit);
            float TriggerY = GetUnitY(TriggerUnit);
            
            if (PandoraDB_Distance[index] > 0.0)
            {
                // сокращаем дистанцию
                PandoraDB_Distance[index]-=PandoraDB_Speed[index];
                TriggerX=TriggerX+PandoraDB_CSpeed[index];
                TriggerY=TriggerY+PandoraDB_SSpeed[index];
                SetUnitX(TriggerUnit,TriggerX);
                SetUnitY(TriggerUnit,TriggerY);
                
                #if (!onPeriod)
                    onPeriod
                #endif
            }
            else
            {
                #if (!onEnd)
                    onEnd
                #endif
                PandoraDB_Dummy[index] = null;
                PandoraDB_Speed[index] = 0.0;
                PandoraDB_CSpeed[index] = 0.0;
                PandoraDB_SSpeed[index] = 0.0;
                PandoraDB_Distance[index] = 0.0;
                FlushUserData(t);
                DestroyTimer(t);
            }
            t=null;
            TriggerUnit=null;
        }
    }
        
    #define TMoveDummyToCoord(spellDummy, xCoord, yCoord, speed, onPeriod, onEnd) = 
    {
        vblock
        {
            timer t = CreateTimer();
            int index = GetIndex(t);
            float spellDummyX = GetUnitX(spellDummy);
            float spellDummyY = GetUnitY(spellDummy);
            PandoraDB_Dummy[index] = spellDummy;
            float angle = (57.295827 * Atan2(yCoord-spellDummyY,xCoord-spellDummyX));
            SetUnitFacing(PandoraDB_Dummy[index],angle);
            PandoraDB_Speed[index] = speed;
            PandoraDB_CSpeed[index] = speed*Cos(angle*0.0175);
            PandoraDB_SSpeed[index] = speed*Sin(angle*0.0175);
            PandoraDB_Distance[index] = SquareRoot((xCoord-spellDummyX)*(xCoord-spellDummyX)+(yCoord-spellDummyY)*(yCoord-spellDummyY));
            TimerStart(t,.04,true,lambda void(){TimerAction(onPeriod, onEnd)});
            t=null;
        }
    }
}

scope KunaiBomb

#define
{
    private abilCode = 'A009';
    private abilRang = E;
    private abilType = TAI;
    private exploisonDamage = 300.0;
    private exploisonRange = 300.0;
    private dummyModelPath = "NoteKunai.mdx";
    private dummyModelSize = 0.5;
    private dummySpeed = 40.0
    private effectModelPath = "SFX\\NewGroundEX.mdx"
    private effectModelSize = 1.5;
    private effectModelAngle1 = 0.0;
    private effectModelAngle2 = 0.0;
    private effectModelTime = 0.5;
}

callback onUnitSpellEffect(abilCode) 
{

    unit caster = GetTriggerUnit();
    float spellTargetX = GetSpellTargetX();
    float spellTargetY = GetSpellTargetY();
    unit dummy = Dummy_CreateDummy(caster, dummyModelPath, dummyModelSize,0.0) ;
    
    TMoveDummyToCoord(\
        dummy,\
        spellTargetX,\
        spellTargetY,\
        dummySpeed,\
        EmptyAction,\
        CreateDummySfx(effectModelPath, TriggerX, TriggerY, effectModelAngle1, effectModelAngle2, effectModelSize, effectModelTime);\
        TDamageEnemyArea(TriggerUnit, exploisonRange, exploisonDamage, abilType);\
        Dummy_RemoveDummy(TriggerUnit););
    caster = null;
    dummy = null;
}

endscope

library Damage uses GroupPick,ElementalSys
{
    public void DamageEnemyArea(unit u, float range, float abilDamage, int abilType)
    {
        group EnumUnits = GetUnitEnemyInRange(u, range)
        loop
        {
            unit TargetUnit = FirstOfGroup(EnumUnits)
            exitwhen TargetUnit == null
            CauseDamageUnitX(u,TargetUnit,abilDamage,abilType)
            GroupRemoveUnit(EnumUnits,TargetUnit)
            TargetUnit = null
        }
        DestroyGroup(EnumUnits)
        EnumUnits = null
    }
    
    #define TDamageEnemyArea(TriggerUnit, range, abilDamage, abilType) = 
    {
        Damage_DamageEnemyArea(TriggerUnit, range, abilDamage, abilType)
    }
}

library PandoraDB
{
    public unit array Caster
    // дамми
    public unit array Dummy
    // цель
    public unit array Target
    // скорость
    public float array Speed
    // косинус*угол скорости
    public float array CSpeed
    // синус*угол скорости
    public float array SSpeed
    // угол
    //public float array Angle
    // дистанция
    public float array Distance

}