function Trig_Spell_Conditions takes nothing returns boolean
        return GetSpellAbilityId() == 'A000'
endfunction

function Trig_Spell_Actions2 takes nothing returns nothing
local timer t = GetExpiredTimer()
local integer id = GetHandleId(t)
local unit u = LoadUnitHandle(udg_Hash,id,0)
local effect e1 = LoadEffectHandle(udg_Hash,id,4)
if (OrderId2String(GetUnitCurrentOrder(u)) != "channel") then
call DestroyEffect(e1) 
call DestroyTimer(t)
call SetUnitTimeScale(u,1)
call FlushChildHashtable(udg_Hash,id)
call SetUnitInvulnerable(u,false)
else
endif
set u = null
set e1 = null
set t = null
endfunction


function Trig_Spell_Actions takes nothing returns nothing
local unit u = GetTriggerUnit()
local timer t = CreateTimer()
local integer id = GetHandleId(t)
local string s = "Abilities\\Spells\\Undead\\FreezingBreath\\FreezingBreathTargetArt.mdl"
local effect e1 = AddSpecialEffectTarget(s,u,"origin")
call SaveUnitHandle(udg_Hash,id,0,u)
call SaveEffectHandle(udg_Hash,id,4,e1)
call SetUnitInvulnerable(u,true)
call SetUnitTimeScale(u,0)
call TimerStart(t,0.03,true,function Trig_Spell_Actions2)
set u = null
set s = null
set e1 = null
endfunction

//===========================================================================
function InitTrig_Spell takes nothing returns nothing
    set gg_trg_Spell = CreateTrigger()
    call TriggerRegisterAnyUnitEventBJ( gg_trg_Spell, EVENT_PLAYER_UNIT_SPELL_EFFECT )
    call TriggerAddCondition( gg_trg_Spell, Condition( function Trig_Spell_Conditions ) )
    call TriggerAddAction( gg_trg_Spell, function Trig_Spell_Actions )
endfunction

function Trig_Spell_Conditions takes nothing returns boolean
return GetSpellAbilityId() == 'A000'
endfunction

function GetUnitZ takes unit u returns real
local location loc=GetUnitLoc(u)
local real r=GetLocationZ(loc)+GetUnitFlyHeight(u)
call RemoveLocation(loc)
set loc=null
return r
endfunction

function SR_Spell takes real xa, real ya, real xb, real yb returns real
return SquareRoot((xa-xb)*(xa-xb)+(ya-yb)*(ya-yb))
endfunction

function Trig_Spell_Actions2 takes nothing returns nothing
local timer t = GetExpiredTimer()
local integer id = GetHandleId(t)
local unit u = LoadUnitHandle(udg_Hash,id,0)
local unit c = LoadUnitHandle(udg_Hash,id,1)
local real x1 = GetUnitX(c)
local real y1 = GetUnitY(c)
local real x = GetUnitX(u)
local real y = GetUnitY(u)
local lightning l = LoadLightningHandle(udg_Hash,id,4)
local real a = Atan2(y1-y,x1-x)
local unit d
if SR_Spell(x,y,x1,y1) > 36. then
call SetUnitX(u,x+37.5*Cos(a))
call SetUnitY(u,y+37.5*Sin(a))
call MoveLightningEx(l,false,x,y,GetUnitZ(u)+50.,x1,y1,GetUnitZ(c)+50.)
call DestroyEffect(AddSpecialEffectTarget("Abilities\\Weapons\\PhoenixMissile\\Phoenix_Missile.mdl&q​uot;,u,"chest"))
call SetUnitFacing(u,a*bj_RADTODEG)
set d = CreateUnit(GetOwningPlayer(u),'h000',x,y,GetUnitFacing(u))
call UnitApplyTimedLife(d,'BTLF',7.)
call IssuePointOrder(d,"silence",x,y)
call SetUnitAbilityLevel(d,'A002',GetUnitAbilityLevel(u,'A000'))
else
call UnitRemoveAbility(u,'A001')
call DestroyEffect(LoadEffectHandle(udg_Hash,id,5))
call DestroyTimer(t)
call DestroyLightning(l)
call FlushChildHashtable(udg_Hash,id)
endif
set u = null
set t = null
set c = null
set d = null
set l = null
endfunction

function Trig_Spell_Actions takes nothing returns nothing
local unit u = GetTriggerUnit()
local unit c = GetSpellTargetUnit()
local real x = GetUnitX(u)
local real y = GetUnitY(u)
local real x1 = GetUnitX(c)
local real y1 = GetUnitY(c)
local timer t = CreateTimer()
local integer id = GetHandleId(t)
call SaveUnitHandle(udg_Hash,id,0,u)
call SaveUnitHandle(udg_Hash,id,1,c)
call SaveLightningHandle(udg_Hash,id,4,AddLightningEx("LEAS",false,x,y,GetUnitZ(u)+50,x1,y1,Get​UnitZ(c)+50))
call SaveEffectHandle(udg_Hash,id,5,AddSpecialEffectTarget("Abilities\\Spells\\Human\\AerialShackles​\\AerialShacklesTarget.mdl",c,"chest"))
call UnitAddAbility(u,'A001')
call TimerStart(t,0.025,true,function Trig_Spell_Actions2)
set u = null
set t = null
set c = null
endfunction

//===========================================================================
function InitTrig_Spell takes nothing returns nothing
set gg_trg_Spell = CreateTrigger()
call TriggerRegisterAnyUnitEventBJ(gg_trg_Spell,EVENT_PLAYER_UNIT_SPELL_EFFECT)
call TriggerAddCondition(gg_trg_Spell,Condition(function Trig_Spell_Conditions))
call TriggerAddAction(gg_trg_Spell,function Trig_Spell_Actions)
endfunction

//    Chain Element model By Infrisios (hiveworkshop)
//    Chain Storm model by Judash (hiveworkshop)
//    code by Hate (XGM)
//    original idea of skill by NCSoft (some koreans guys)
//    landscape by Nikz (XGM)

scope IllusionChains
include "cj_types.j"

//globals
private hashtable hash = InitHashtable()
private group Pull_gr = CreateGroup(), FiltGroup = CreateGroup()
private int count
private unit for_filter = null, for_filter2 = null

define {
   private IC_CHAIN = 'h000' // chain element unit
   private IC_GLOW = 'h001' // glow unit
   private IC_DUMMY = 'h002' // dummy unit for stun
   private IC_DUMMY_DEBUFF = 'h003' // unit for debuff dummy
   private IC_SKILL = 'A000' // skill-activator
   private IC_DEBUFF = 'A001' // skill for debuff
   private IC_DEBUFF2 = 'B000' // debuff
   private saveS = SaveInteger(hash, GetHandleId(t1), 0,DB)
   private loadS = LoadInteger(hash, GetHandleId(t), 0)
   private CT = CreateTimer()
} 


real ABU (unit A, unit B) {
    return Atan2(GetUnitY(B)-GetUnitY(A), GetUnitX(B)-GetUnitX(A))*bj_RADTODEG
}

real DBU (unit A, unit B) {
return SquareRoot((GetUnitX(B) - GetUnitX(A)) * (GetUnitX(B) - GetUnitX(A)) + (GetUnitY(B) - GetUnitY(A)) * (GetUnitY(B) - GetUnitY(A)))
}

real DBP (unit A, real x_B, real y_B) {
return SquareRoot((x_B - GetUnitX(A)) * (x_B - GetUnitX(A)) + (y_B - GetUnitY(A)) * (y_B - GetUnitY(A)))
}

struct SomeRandomStruct
unit eff, target
real time
endstruct

struct Pull
    unit victim
    unit source
    real x, y, start_x, start_y, time, angle, mod
    
    
method ex takes void returns void
    this.mod = this.mod/1.3
    this.x = this.mod * Cos(this.angle * bj_DEGTORAD)
    this.y = this.mod * Sin(this.angle * bj_DEGTORAD)
    SetUnitPosition(this.victim, GetUnitX(this.victim)+this.x, GetUnitY(this.victim)+this.y)
endmethod 

endstruct


struct Chain

unit array chain[12]
unit array glow[12]
unit ef


    void replace(unit src, unit vct){
    int c = 0
    real distance = DBU(src,vct), m_u = distance/12., bonus = distance/12., ang = ABU(src,vct)
    real h_x = GetUnitX(src), h_y = GetUnitY(src)
    
        while (c++ < 12) {
        SetUnitX(this.chain[c], h_x + (m_u * Cos(ang*(bj_PI/180.))))
        SetUnitY(this.chain[c], h_y + (m_u * Sin(ang*(bj_PI/180.))))
    
        SetUnitX(this.glow[c], h_x + (m_u * Cos(ang*(bj_PI/180.))))
        SetUnitY(this.glow[c], h_y + (m_u * Sin(ang*(bj_PI/180.))))
        
       
        
        SetUnitFacingTimed(chain[c], ang, 0.)
        m_u += bonus
        }
        SetUnitX(this.ef,GetUnitX(vct))
        SetUnitY(this.ef,GetUnitY(vct))
    
    }

    void add(unit w, unit v){
    int c = 0
    real distance = DBU(v,w), m_u = distance/12., bonus = distance/12., ang = ABU(w,v)
    real h_x = GetUnitX(w), h_y = GetUnitY(w)
    
        this.ef = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), IC_DUMMY_DEBUFF,GetUnitX(v),GetUnitY(v), GetRandomReal(0.,360.))
        while (c++ < 12) {
        chain[c] = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), IC_CHAIN, GetUnitX(w)+(m_u * Cos(90.*(bj_PI/180.))),GetUnitY(w)+(m_u * Sin(90.*(bj_PI/180.))),ang)
        SetUnitPathing(this.chain[c],false)
        SetUnitX(this.chain[c], h_x + (m_u * Cos(ang*(bj_PI/180.))))
        SetUnitY(this.chain[c], h_y + (m_u * Sin(ang*(bj_PI/180.))))
        
        glow[c] = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), IC_GLOW, GetUnitX(w)+(m_u * Cos(90.*(bj_PI/180.))),GetUnitY(w)+(m_u * Sin(90.*(bj_PI/180.))),ang)
        SetUnitPathing(this.glow[c],false)
        SetUnitX(this.glow[c], h_x + (m_u * Cos(ang*(bj_PI/180.))))
        SetUnitY(this.glow[c], h_y + (m_u * Sin(ang*(bj_PI/180.))))
        m_u += bonus
        }
        SetUnitX(this.ef,GetUnitX(v))
        SetUnitY(this.ef,GetUnitY(v))
    }

    void remove() {
    int c = 0
    
        while (c++ < 12){
            RemoveUnit(this.chain[c])
            this.chain[c] = null
            RemoveUnit(this.glow[c])
            this.glow[c] = null
            RemoveUnit(this.ef)
            this.ef = null
        }
        
    this.destroy()
    }

endstruct


private void RemoveSlow() {
int h = GetHandleId(GetExpiredTimer())
SomeRandomStruct srs = LoadInteger(hash,h,0)
    if srs.time <= 0. or GetUnitAbilityLevel(srs.target,IC_DEBUFF2) != 1
        KillUnit(srs.eff)
        UnitRemoveAbility(srs.target, IC_DEBUFF) 
        UnitRemoveAbility(srs.target, IC_DEBUFF2) 
        srs.eff = null
        srs.target = null
        srs.destroy()
        FlushChildHashtable(hash,h)
        DestroyTimer(GetExpiredTimer())
    else
        srs.time -= 0.05
        IssuePointOrder(srs.eff, "move",GetUnitX(srs.target),GetUnitY(srs.target))
    endif
}


private function PeriodicPull takes nothing returns nothing
timer t = GetExpiredTimer(), RmvSlv
Pull DB = loadS
SomeRandomStruct srs
Chain DA = LoadInteger(hash, GetHandleId(t),1)
real distance = DBP(DB.victim, DB.start_x, DB.start_y)

    if GetUnitState(DB.victim, UNIT_STATE_LIFE) <= 0.045 or distance > 1200. then
        GroupRemoveUnit(Pull_gr, DB.victim)
        SetUnitPathing(DB.victim,true)
        DA.remove()
        DB.destroy()
        FlushChildHashtable(hash,GetHandleId(t))
        DestroyTimer(t)
    else
        if (distance < 245. and distance > 85.) then
            DB.ex()
            DA.replace(DB.source,DB.victim)
        elseif distance <= 85. then
            DA.remove()
            IssueTargetOrder(CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE),IC_DUMMY,GetUnitX(DB.victim), GetUnitY(DB.victim), 90.),"thunderbolt",DB.victim)
            RmvSlv = CT
            
            bj_lastCreatedUnit = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), IC_DUMMY_DEBUFF,GetUnitX(DB.victim),GetUnitY(DB.victim), GetRandomReal(0.,360.))
            IssueTargetOrder(bj_lastCreatedUnit, "move",DB.victim)
            UnitAddAbility(DB.victim, IC_DEBUFF)
            srs = SomeRandomStruct.create()
            srs.eff = bj_lastCreatedUnit
            srs.target = DB.victim
            srs.time = 10.
            SaveInteger(hash,GetHandleId(RmvSlv), 0, srs)
            TimerStart(RmvSlv, 0.05, true, function RemoveSlow)
            
            SetUnitPathing(DB.victim,true)
            GroupRemoveUnit(Pull_gr, DB.victim)
            
            RmvSlv = null
            DB.destroy()
            FlushChildHashtable(hash,GetHandleId(t))
            DestroyTimer(t)
        else
            SetUnitPosition(DB.victim, GetUnitX(DB.victim)+DB.x, GetUnitY(DB.victim)+DB.y)
            DA.replace(DB.source,DB.victim)
        endif
    endif
t = null
endfunction


private bool enum_filt (){
unit en = GetFilterUnit()
bool b = false

    if (GetUnitState(en,UNIT_STATE_LIFE) > 0.045 and IsUnitEnemy(en, GetOwningPlayer(for_filter)) and not IsUnitType(en, UNIT_TYPE_STRUCTURE) and not IsUnitType(en, UNIT_TYPE_FLYING) and count != 0 and en != for_filter2)
        b = true
        count--
    endif

en = null
return b
}

void Trig_Illusion_Chains_Actions(unit caster, unit victim, timer t1) {
Pull DB = Pull.create()
Chain DA1 = Chain.create()

    DB.start_x = GetUnitX(caster)
    DB.start_y = GetUnitY(caster)
    DB.victim = victim
    DB.source = caster
    DB.angle = ABU(victim, caster)
    DB.mod = 48.
    DB.x = 20.1 * Cos(DB.angle * bj_DEGTORAD)
    DB.y = 20.1 * Sin(DB.angle * bj_DEGTORAD)
    UnitDamageTarget(caster, victim, GetHeroStr(caster, true)*2, true, false, ATTACK_TYPE_NORMAL, DAMAGE_TYPE_NORMAL, WEAPON_TYPE_WHOKNOWS)
    DA1.add(caster,victim)
        if IsUnitInGroup(victim,Pull_gr)
            DA1.remove()
            DB.destroy()
            DestroyTimer(t1)
            return
        else
            SetUnitPathing(victim,false)
            GroupAddUnit(Pull_gr, victim)
            saveS
            SaveInteger(hash, GetHandleId(t1),1, DA1)
            TimerStart(t1, 0.02, true, function PeriodicPull)
        endif
}

void TargetsCheck(unit s,unit v){
Trig_Illusion_Chains_Actions(s,v,CT)
if GetUnitAbilityLevel(s, IC_SKILL) > 1 then
    for_filter = s
    for_filter2 = v
    count = 2
    GroupClear(FiltGroup)
    GroupEnumUnitsInRange(FiltGroup, GetUnitX(v), GetUnitY(v), 250. ,Filter(function enum_filt))
    
    if GetUnitAbilityLevel(s, IC_SKILL) >= 2 then
    for_filter = FirstOfGroup(FiltGroup)
        if for_filter != null then
            GroupRemoveUnit(FiltGroup,for_filter)
            Trig_Illusion_Chains_Actions(s,for_filter,CT)
        endif
    endif
    
    if GetUnitAbilityLevel(s, IC_SKILL) == 3 then
    for_filter = FirstOfGroup(FiltGroup)
        if for_filter != null then
            GroupRemoveUnit(FiltGroup,for_filter)
            Trig_Illusion_Chains_Actions(s,for_filter,CT)
        endif
    endif
endif
}


function Trig_Illusion_Chains_Conditions takes nothing returns boolean
    if GetSpellAbilityId() == IC_SKILL then
        TargetsCheck(GetSpellAbilityUnit(), GetSpellTargetUnit())
    endif
return false
endfunction


//===========================================================================
function InitTrig_Illusion_Chains takes nothing returns nothing
    set gg_trg_Illusion_Chains = CreateTrigger(  )
    call TriggerRegisterAnyUnitEventBJ( gg_trg_Illusion_Chains, EVENT_PLAYER_UNIT_SPELL_EFFECT )
    call TriggerAddCondition( gg_trg_Illusion_Chains, Condition( function Trig_Illusion_Chains_Conditions ) )
endfunction

endscope

// code by Hate (XGM)
// original idea of skill by NCSoft (some korean guys)

include "cj_types.j"
scope SwordStorm

define {
    private SS_SKILL = 'A000' // ability-activator
    private SS_STUN_DUMMY = 'h000' // unit-dummy
    private SS_DSTR_STR = 'B000' // destructable 1
    private SS_DSTR_UP = 'B001' // destructable 2
    private damage_lvl_1 = (GetHeroStr(s.caster, true)*2.)*GetRandomReal(0.85,1.25)
    private damage_lvl_2 = (GetHeroStr(s.caster, true)*3.)*GetRandomReal(0.85,1.25)
    private damage_lvl_3 = (GetHeroStr(s.caster, true)*4.)*GetRandomReal(0.85,1.25)
    // ^-------end-------^
    private CT = CreateTimer()
    private SetData(h,d) = SaveInteger(hash, GetHandleId(h), 0, d)
    private GetData(h) = LoadInteger(hash, GetHandleId(h), 0)
    private clear(h) = FlushChildHashtable(hash, GetHandleId(h))
    private SaveDest(h,num,d) = SaveDestructableHandle(hash, GetHandleId(h), num, d)
       
}

// globals
private hashtable hash = InitHashtable()
private group CastGroup = CreateGroup(), DmgGroup = CreateGroup()
private location loc = Location(0.,0.)
private trigger EndCastRunMain = CreateTrigger(), CastBreak = CreateTrigger()
private unit for_filt1 = null
private int g_power = 0
private force ShakeF = CreateForce(), CopyedForce = CreateForce()

private real ABU (unit A, unit B) {
    return Atan2(GetUnitY(B)-GetUnitY(A), GetUnitX(B)-GetUnitX(A))*bj_RADTODEG
}

private real ABP (real A_x,real A_y, real B_x,real B_y) {
    return Atan2(B_y-A_y, B_x-A_x)*bj_RADTODEG
}

void ForceAddForce (){
    call ForceAddPlayer(CopyedForce, GetEnumPlayer())
}

force CopyForce(force f){
CopyedForce = CreateForce()
    ForForce(f, function ForceAddForce)
return CopyedForce
}
//----------------=================-------------------
function f_end takes nothing returns nothing
    CameraClearNoiseForPlayer(GetEnumPlayer())
endfunction

function f_start_power takes nothing returns nothing
    CameraSetEQNoiseForPlayer( GetEnumPlayer(), g_power )
endfunction

void shake_time () {
force f = LoadForceHandle(hash, GetHandleId(GetExpiredTimer()), 0)
     ForForce(f, function f_end)
ForceClear(f)
clear(GetExpiredTimer())
DestroyTimer(GetExpiredTimer())
DestroyForce(f)
f = null
}

bool players_filter(){
ForceAddPlayer(ShakeF, GetOwningPlayer(GetFilterUnit()))
return false
}

void shake (unit u, real time, int power) {
group g = CreateGroup()
timer t = CreateTimer()
force f1
    GroupEnumUnitsInRange(g, GetUnitX(u),GetUnitY(u), 1050., Filter(function players_filter))
    f1 = CopyForce(ShakeF)
    SaveForceHandle(hash, GetHandleId(t), 0, f1)
    TimerStart(t, time, false, function shake_time)
    g_power = power
    ForForce(f1, function f_start_power)
DestroyGroup(g)
g = null
t = null
f1 = null
}

private texttag TextBar (string s, unit whichUnit, real size, real red, real green, real blue ) {
    bj_lastCreatedTextTag = CreateTextTag()
    SetTextTagText(bj_lastCreatedTextTag, s, (size * 0.023) / 10)
    SetTextTagPosUnit(bj_lastCreatedTextTag, whichUnit, 10)
    SetTextTagColor(bj_lastCreatedTextTag, PercentToInt(red, 255), PercentToInt(green, 255),PercentToInt(blue, 255), 0)
return bj_lastCreatedTextTag
}

private struct Cast
    unit caster = null
    texttag Bar = null
    real CastTime = 1. , One = 1./33
    int what = 0
    effect ef, ef2
    
endstruct

private struct SomeStr

    unit caster
    group FlagGroup = CreateGroup()
    real range = 0., angle
    int AbilLvl
    
    void remove (){
        this.caster = null
        GroupClear(this.FlagGroup)
        DestroyGroup(this.FlagGroup)
        this.FlagGroup = null
        this.destroy()
    }
endstruct

private void RemDestr() {
RemoveDestructable(LoadDestructableHandle(hash, GetHandleId(GetExpiredTimer()), 0))
clear(GetExpiredTimer())
DestroyTimer(GetExpiredTimer())
}

private void RemDestr2() {
int h = GetHandleId(GetExpiredTimer())
    RemoveDestructable(LoadDestructableHandle(hash, h, 0))
    RemoveDestructable(LoadDestructableHandle(hash, h, 1))
    RemoveDestructable(LoadDestructableHandle(hash, h, 2))
clear(GetExpiredTimer())
DestroyTimer(GetExpiredTimer())
}

bool GroupFilt(){ 
return (GetUnitState(GetFilterUnit(), UNIT_STATE_LIFE) > 0.045 and IsUnitEnemy(GetFilterUnit(), GetOwningPlayer(for_filt1)))
}

private void SS_main_loop_actions () {
SomeStr s = GetData(GetExpiredTimer())
real some, needx, needy
timer newT
    if s.range > 600.
        s.remove()
        clear(GetExpiredTimer())
        DestroyTimer(GetExpiredTimer())
    else
        
        s.range += 20.
        needx = GetUnitX(s.caster)+(s.range*Cos(s.angle*bj_DEGTORAD))
        needy = GetUnitY(s.caster)+(s.range*Sin(s.angle*bj_DEGTORAD))
        
        if s.range < 200. { bj_lastCreatedDestructable = CreateDestructable(SS_DSTR_UP,needx,needy,s.angle, 0.35, 0) }
        elseif s.range > 200. and s.range < 400. { bj_lastCreatedDestructable = CreateDestructable(SS_DSTR_UP,needx,needy,s.angle, 0.3, 0) }
        elseif s.range > 400. and s.range <= 600. { bj_lastCreatedDestructable = CreateDestructable(SS_DSTR_UP,needx,needy,s.angle, 0.25, 0) }
        SetDestructableAnimation(bj_lastCreatedDestructable,"stand")
        newT = CT
        SaveDest(newT,0,bj_lastCreatedDestructable)
        TimerStart(newT, 1.5, false, function RemDestr)
        newT = null
        
        GroupClear(DmgGroup)
        for_filt1 = s.caster
        GroupEnumUnitsInRange(DmgGroup, needx,needy, 95., Filter(function GroupFilt))
            // loop
            while (FirstOfGroup(DmgGroup) != null) {
                bj_lastCreatedUnit = FirstOfGroup(DmgGroup)
                GroupRemoveUnit(DmgGroup, bj_lastCreatedUnit)
                if not IsUnitInGroup(bj_lastCreatedUnit, s.FlagGroup)
                // ------>
                    GroupAddUnit(s.FlagGroup, bj_lastCreatedUnit)
                    if s.AbilLvl == 1 { UnitDamageTarget(s.caster,bj_lastCreatedUnit,damage_lvl_1,true,false,ATTACK_TYPE_MELEE ,DAMAGE_TYPE_NORMAL, WEAPON_TYPE_WHOKNOWS) }
                    elseif s.AbilLvl == 2 { UnitDamageTarget(s.caster,bj_lastCreatedUnit,damage_lvl_2,true,false,ATTACK_TYPE_MELEE ,DAMAGE_TYPE_NORMAL, WEAPON_TYPE_WHOKNOWS) }
                    elseif s.AbilLvl == 3 { UnitDamageTarget(s.caster,bj_lastCreatedUnit,damage_lvl_3,true,false,ATTACK_TYPE_MELEE ,DAMAGE_TYPE_NORMAL, WEAPON_TYPE_WHOKNOWS) }
                    IssueTargetOrder( CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE),SS_STUN_DUMMY, needx,needy,0.), "thunderbolt", bj_lastCreatedUnit )
                // <------
                endif
            }
            // end loop
    endif
}


private void CastBar(){
timer t = GetExpiredTimer()
Cast m = GetData(t)

    if m.what == 33 or not IsUnitInGroup(m.caster, CastGroup) then
        DestroyTextTag(m.Bar)
        m.caster = null
        m.destroy()
        clear(t)
        DestroyTimer(t)
    else
        SetTextTagText(m.Bar, udg_CastBar_Text[m.what], (10.5 * 0.023) / 10.)
        m.what++
    endif
    
t = null
}

private void CastProcessSimple(){
timer t = GetExpiredTimer(), t2
Cast n = GetData(t)

    if n.CastTime <= 0. then
        DestroyEffect(n.ef)
        DestroyEffect(n.ef2)
        GroupRemoveUnit(CastGroup, n.caster)
        n.caster = null
        n.destroy()
        clear(t)
        DestroyTimer(t)
        t2 = null
    elseif not IsUnitInGroup(n.caster, CastGroup) \
    or GetUnitState(n.caster, UNIT_STATE_LIFE) <= 0.045 \
    or not ((GetUnitAbilityLevel(n.caster, 'BSTN')==0) \
    and (GetUnitAbilityLevel(n.caster,'BPSE')==0) \
    and (GetUnitAbilityLevel(n.caster,'BUsl')==0) \
    and (GetUnitAbilityLevel(n.caster,'BUst')==0) \
    and (GetUnitAbilityLevel(n.caster,'BUim')==0) \
    and (GetUnitAbilityLevel(n.caster,'Bwea')==0) \
    and (GetUnitAbilityLevel(n.caster,'Bweb')==0) \
    and (GetUnitAbilityLevel(n.caster,'Bmlt')==0)) \
    then \
    // ------>
        DestroyEffect(n.ef)
        DestroyEffect(n.ef2)
        SetUnitAnimation(n.caster, "stand")
        IssueImmediateOrder(n.caster, "stop")
        n.destroy()
        clear(t)
        DestroyTimer(t)
    // <------
    else
        SetUnitAnimation(n.caster, "ready")
        n.CastTime -= 0.01
    endif
    
t = null
}

private void SS_CastStartSimple(unit caster){
Cast n = Cast.create()
Cast m = Cast.create()
timer t1 = CT, t2 = CT
    
    m.caster = caster
    n.ef = AddSpecialEffectTarget("Abilities\\Spells\\Orc\\Bloodlust\\BloodlustTarget.mdl",caster,&qu​ot;hand right")
    n.ef2 = AddSpecialEffectTarget("Abilities\\Spells\\Orc\\Bloodlust\\BloodlustTarget.mdl",caster,&qu​ot;weapon")
    n.caster = caster
    m.Bar = TextBar(udg_CastBar_Text[0], caster, 10.5, 100., 100., 100.)
    GroupAddUnit(CastGroup, caster)
    
    SetData(t1, n)
    SetData(t2, m)
    
    TimerStart(t1, 0.01,true, function CastProcessSimple)
    TimerStart(t2, 1./33. ,true, function CastBar)
    
t1 = null
t2 = null
}

void EndCastRunMain_Act(unit caster,unit target, timer t) {
SomeStr s = SomeStr.create()
real x = GetUnitX(caster), y = GetUnitY(caster), ang = ABU (caster, target), needx, needy
timer t_destr = CT
    
    needx = x+(90.*Cos((ang-50.)*bj_DEGTORAD))
    needy = y+(90.*Sin((ang-50.)*bj_DEGTORAD))
    bj_lastCreatedDestructable = \
CreateDestructableZ(SS_DSTR_STR,needx, needy,50.,ABP(needx,needy,x+(600.*Cos(ang*bj_DEGTORAD)),y+(600.*Sin(ang*bj_DEGTORAD))), 2., 0)
    SetDestructableAnimation(bj_lastCreatedDestructable,"stand")   
    SaveDest(t_destr,0, bj_lastCreatedDestructable)
    
    
    needx = x+(90.*Cos((ang+50.)*bj_DEGTORAD))
    needy = y+(90.*Sin((ang+50.)*bj_DEGTORAD))
    bj_lastCreatedDestructable = \
CreateDestructableZ(SS_DSTR_STR,needx,needy,50.,ABP(needx,needy,x+(600.*Cos(ang*bj_DEGTORAD)),y+(600​.*Sin(ang*bj_DEGTORAD))), 2., 0)
    SetDestructableAnimation(bj_lastCreatedDestructable,"stand")
    SaveDest(t_destr,1, bj_lastCreatedDestructable)
    
    
    needx = x+(120.*Cos((ang)*bj_DEGTORAD))
    needy = y+(120.*Sin((ang)*bj_DEGTORAD))
    bj_lastCreatedDestructable = \
CreateDestructableZ(SS_DSTR_STR,needx, needy,50.,ABU(caster,target), 2.1, 0)
    SetDestructableAnimation(bj_lastCreatedDestructable,"stand")
    SaveDest(t_destr,2, bj_lastCreatedDestructable)
    
    TimerStart(t_destr, 2., false, function RemDestr2)
    shake(caster, 0.95, 3)
    
    DestroyEffect(AddSpecialEffect("Abilities\\Spells\\Orc\\WarStomp\\WarStompCaster.mdl",need​x,needy))
    GroupAddUnit(s.FlagGroup, caster)
    s.caster = caster
    s.AbilLvl = GetUnitAbilityLevel(caster, SS_SKILL)
    s.angle = ABU(caster,target)
    SetData(t,s)
    TimerStart(t,0.005, true, function SS_main_loop_actions )
    
t_destr = null
}

bool EndCastRunMain_Conds () { 
    if GetSpellAbilityId() == SS_SKILL  { EndCastRunMain_Act(GetSpellAbilityUnit(),GetSpellTargetUnit(),CT) }
return false
}


function Trig_Sword_Storm_Actions takes nothing returns bool
if GetSpellAbilityId() == SS_SKILL { SS_CastStartSimple(GetSpellAbilityUnit()) }
return false
endfunction

function CastBreak_Conditions takes nothing returns bool
    if IsUnitInGroup(GetTriggerUnit(), CastGroup) { GroupRemoveUnit( CastGroup, GetTriggerUnit() ) }
return false
endfunction


//===========================================================================
function InitTrig_Sword_Storm takes nothing returns nothing
    gg_trg_Sword_Storm = CreateTrigger(  )
    TriggerRegisterAnyUnitEventBJ( gg_trg_Sword_Storm, EVENT_PLAYER_UNIT_SPELL_CHANNEL )
    TriggerAddCondition( gg_trg_Sword_Storm, Condition(function Trig_Sword_Storm_Actions ))
    
    TriggerRegisterAnyUnitEventBJ(EndCastRunMain, EVENT_PLAYER_UNIT_SPELL_EFFECT)
    TriggerAddCondition(EndCastRunMain, Condition(function EndCastRunMain_Conds))
    
    TriggerRegisterAnyUnitEventBJ( CastBreak, EVENT_PLAYER_UNIT_ISSUED_TARGET_ORDER )
     TriggerRegisterAnyUnitEventBJ( CastBreak, EVENT_PLAYER_UNIT_ISSUED_POINT_ORDER )
      TriggerRegisterAnyUnitEventBJ( CastBreak, EVENT_PLAYER_UNIT_ISSUED_ORDER )
    TriggerAddCondition( CastBreak, Condition( function CastBreak_Conditions ) )
endfunction

endscope

library CastBar initializer barInit
string array udg_CastBar_Text[34]

private void barInit() {
set udg_CastBar_Text[0] = "|cff333333'''''''''''''''''''''''''''''''''|r"
  set udg_CastBar_Text[1] = "|cffffae00'|r|cff333333''''''''''''''''''''''''''''''''|r"
  set udg_CastBar_Text[2] = "|cffffae00'|r|cff333333''''''''''''''''''''''''''''''''|r"
  set udg_CastBar_Text[3] = "|cffffae00''|r|cff333333'''''''''''''''''''''''''''''''|r"
  set udg_CastBar_Text[4] = "|cffffae00'''|r|cff333333''''''''''''''''''''''''''''''|r"
  set udg_CastBar_Text[5] = "|cffffae00''''|r|cff333333'''''''''''''''''''''''''''''|r"
  set udg_CastBar_Text[6] = "|cffffae00'''''|r|cff333333''''''''''''''''''''''''''''|r"
  set udg_CastBar_Text[7] = "|cffffae00''''''|r|cff333333'''''''''''''''''''''''''''|r"
  set udg_CastBar_Text[8] = "|cffffae00'''''''|r|cff333333''''''''''''''''''''''''''|r"
  set udg_CastBar_Text[9] = "|cffffae00''''''''|r|cff333333'''''''''''''''''''''''''|r"
 set udg_CastBar_Text[10] = "|cffffae00'''''''''|r|cff333333''''''''''''''''''''''''|r"
 set udg_CastBar_Text[11] = "|cffffae00''''''''''|r|cff333333'''''''''''''''''''''''|r"
 set udg_CastBar_Text[12] = "|cffffae00''''''''''''|r|cff333333'''''''''''''''''''''|r"
 set udg_CastBar_Text[13] = "|cffffae00'''''''''''''|r|cff333333''''''''''''''''''''|r"
 set udg_CastBar_Text[14] = "|cffffae00''''''''''''''|r|cff333333'''''''''''''''''''|r"
 set udg_CastBar_Text[15] = "|cffffae00'''''''''''''''|r|cff333333''''''''''''''''''|r"
 set udg_CastBar_Text[16] = "|cffffae00''''''''''''''''|r|cff333333'''''''''''''''''|r"
 set udg_CastBar_Text[17] = "|cffffae00'''''''''''''''''|r|cff333333''''''''''''''''|r"
 set udg_CastBar_Text[18] = "|cffffae00''''''''''''''''''|r|cff333333'''''''''''''''|r"
 set udg_CastBar_Text[19] = "|cffffae00'''''''''''''''''''|r|cff333333''''''''''''''|r"
 set udg_CastBar_Text[20] = "|cffffae00''''''''''''''''''''|r|cff333333'''''''''''''|r"
 set udg_CastBar_Text[21] = "|cffffae00'''''''''''''''''''''|r|cff333333''''''''''''|r"
 set udg_CastBar_Text[22] = "|cffffae00''''''''''''''''''''''|r|cff333333'''''''''''|r"
 set udg_CastBar_Text[23] = "|cffffae00'''''''''''''''''''''''|r|cff333333''''''''''|r"
 set udg_CastBar_Text[24] = "|cffffae00''''''''''''''''''''''''|r|cff333333'''''''''|r"
 set udg_CastBar_Text[25] = "|cffffae00'''''''''''''''''''''''''|r|cff333333''''''''|r"
 set udg_CastBar_Text[26] = "|cffffae00''''''''''''''''''''''''''|r|cff333333'''''''|r"
 set udg_CastBar_Text[27] = "|cffffae00'''''''''''''''''''''''''''|r|cff333333''''''|r"
 set udg_CastBar_Text[28] = "|cffffae00''''''''''''''''''''''''''''|r|cff333333'''''|r"
 set udg_CastBar_Text[29] = "|cffffae00'''''''''''''''''''''''''''''|r|cff333333''''|r"
 set udg_CastBar_Text[30] = "|cffffae00''''''''''''''''''''''''''''''|r|cff333333'''|r"
 set udg_CastBar_Text[31] = "|cffffae00'''''''''''''''''''''''''''''''|r|cff333333''|r"
 set udg_CastBar_Text[32] = "|cffffae00''''''''''''''''''''''''''''''''|r|cff333333'|r"
 set udg_CastBar_Text[33] = "|cffffae00'''''''''''''''''''''''''''''''''|r|cff333333|r"
}
endlibrary

// code by Hate (XGM)
// original idea of skill by NCSoft (some korean guys)
// shield model by Judash (hiveworkshop)

include "cj_types.j"
scope PanoplyOfProtection

define {
    private POP_SKILL = 'A002' // ability-activator
    private POP_BUFF_SKILL = 'A003' // ability for buff
    private POP_BUFF = 'B000' // buff
    private POP_DUMMY = 'h001' // for special effect
    private BuffTime_lvl1 = 10. // time of buff
    private BuffTime_lvl2 = 10.
    private BuffTime_lvl3 = 10.
    private Absorb_lvl1 = 1000 // absorb amount
    private Absorb_lvl2 = 2000
    private Absorb_lvl3 = 3000
    // ^-------end-------^
    private SetData(h,d) = SaveInteger(hash, GetHandleId(h), 0, d)
    private GetData(h) = LoadInteger(hash, GetHandleId(h), 0)
    private clear(h) = FlushChildHashtable(hash, GetHandleId(h))
    private msg(s) = DisplayTextToForce(bj_FORCE_ALL_PLAYERS, "|c000099FFDebug Skill (Panoply Of Protection): "+s+"|r")
}

// globals
private trigger TakeDamage = CreateTrigger(), UselessUnits = CreateTrigger()
private group MainGroup = CreateGroup()
private real dmg, absorb, residue
private timer tm = CreateTimer(), someTimer
private hashtable hash = InitHashtable()
private unit need = null


struct BuffTimeStruct
    unit target
    real time
    
   static thistype new(unit A, real abil_lvl){
        thistype NewStruct = thistype.create()
        NewStruct.target = A
        
            if abil_lvl == 1 { 
                NewStruct.time = BuffTime_lvl1 
                SetData(A, Absorb_lvl1)
                }
            elseif abil_lvl == 2 { 
                NewStruct.time = BuffTime_lvl2 
                SetData(A, Absorb_lvl2)
                }
            elseif abil_lvl == 3 { 
                NewStruct.time = BuffTime_lvl3 
                SetData(A, Absorb_lvl3)
            }
        
        return NewStruct
    }
    
endstruct

struct FullStruct
    unit target
    real abs, dm
    
   static thistype new(unit A, real ab, real dg){
        thistype NewStruct = thistype.create()
        NewStruct.target = A
        NewStruct.abs = ab
        NewStruct.dm = dg
        return NewStruct
    }
    
endstruct

void AddSound(string s, real x, real y) {
sound snd = CreateSound(s, false, true, true, 10, 10, "CombatSoundsEAX")
    SetSoundChannel(snd, 40)
    SetSoundVolume(snd, 127)
    SetSoundPitch(snd, 1)
    SetSoundDistances(snd, 600, 10000)
    SetSoundDistanceCutoff(snd, 2100)
    SetSoundConeAngles(snd, 0.0, 0.0, 127)
    SetSoundConeOrientation(snd, 0.0, 0.0, 0.0)
    SetSoundPosition(snd, x, y, 50)
    StartSound(snd)
    KillSoundWhenDone(snd)
snd = null
}

private real ABU (unit A, unit B) {
    return Atan2(GetUnitY(B)-GetUnitY(A), GetUnitX(B)-GetUnitX(A))*bj_RADTODEG
}

void BuffTick (){
BuffTimeStruct bts = GetData(GetExpiredTimer())
real AbsorbAmount = GetData(bts.target)

    if (bts.time <= 0. or GetUnitAbilityLevel(bts.target,POP_BUFF ) == 0 or AbsorbAmount <= 0)
        UnitRemoveAbility(bts.target,POP_BUFF_SKILL)
        UnitRemoveAbility(bts.target,POP_BUFF)
        clear(bts.target)
        bts.target = null
        bts.destroy()
        clear(GetExpiredTimer())
        DestroyTimer(GetExpiredTimer())
    else
        bts.time -= 0.1
    endif
    
}

void UselessUnits_Actions(){
    if IsUnitInGroup(GetTriggerUnit(),MainGroup) { GroupRemoveUnit(MainGroup,GetTriggerUnit()) }
}

void ReversVulnerable(){
    SetUnitInvulnerable(need, false)
}

// this runned if unit have full life
void PanoplyOfProtection_FullLifeCheck () {
FullStruct fs = GetData(GetExpiredTimer())

    if fs.abs > fs.dm
        SetUnitState(fs.target, UNIT_STATE_LIFE, GetUnitState(fs.target, UNIT_STATE_LIFE)+fs.dm)
        SetData(fs.target, GetData(fs.target)-R2I(fs.dm))
    elseif fs.abs < fs.dm
        //dmg = dmg - (dmg - absorb)
        SetUnitState(fs.target, UNIT_STATE_LIFE, GetUnitState(fs.target, UNIT_STATE_LIFE)+(fs.dm - (fs.dm - fs.abs)))
        SetData(fs.target, 0)
    endif
    
fs.target = null
fs.destroy()
clear(GetExpiredTimer())
DestroyTimer(GetExpiredTimer())
}

// main func
void PanoplyOfProtection_MainActions(){
FullStruct fs
real angle, HP

    if (GetEventDamage() > 0 and GetUnitAbilityLevel(GetTriggerUnit(), POP_BUFF) > 0)
        need = GetTriggerUnit()
        
        angle = ABU(need,GetEventDamageSource())
        bj_lastCreatedUnit = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), POP_DUMMY, GetUnitX(need)+(17.*Cos(angle*bj_DEGTORAD)), GetUnitY(need)+(17.*Sin(angle*bj_DEGTORAD)), angle)
        SetUnitPathing(bj_lastCreatedUnit, false)
        SetUnitX(bj_lastCreatedUnit,GetUnitX(need)+(16.*Cos(angle*bj_DEGTORAD)))
        SetUnitY(bj_lastCreatedUnit,GetUnitY(need)+(16.*Sin(angle*bj_DEGTORAD)))
        UnitAddAbility(bj_lastCreatedUnit, 'Arav')
        SetUnitFlyHeight(bj_lastCreatedUnit, GetUnitFlyHeight(need)+3.,0.)
        AddSound("Abilities\\Spells\\Orc\\MirrorImage\\MirrorImage.wav",GetUnitX(need), GetUnitY(need))
        
        absorb = GetData(need)
        HP = GetUnitState(need, UNIT_STATE_LIFE)
        dmg = GetEventDamage()
        
        // =========================
        debug msg("absorb = "+R2S(absorb))
        // =========================
        
        if HP == GetUnitState(need, UNIT_STATE_MAX_LIFE)
            // =========================
            debug msg("victim has full hp")
            debug msg("damage is = "+R2S(dmg))
            debug msg("absorb+hp = "+R2S(HP + absorb))
            // =========================
            if dmg > HP
            debug msg("damage can't be normal absorbed because damage higer than hp")
                residue = (dmg - absorb)
                if residue > HP
                    // =========================
                    debug msg("residue bigger than hp (damage higest than absorb amount and hp). Unit must die =(")
                    // =========================
                else
                    // =========================
                    debug msg("residue lower than hp. No need to die, but absorb shield is broken!")
                    // =========================    
                    SetUnitState(need, UNIT_STATE_LIFE, (HP-residue))
                    SetData(need, 0)
                    SetUnitInvulnerable(need, true)
                    TimerStart(tm, 0.000, false, function ReversVulnerable)
                endif
            else
                someTimer = CreateTimer()
                fs = FullStruct.new(need,absorb,dmg)
                SetData(someTimer, fs)
                TimerStart(someTimer, 0.0, false, function PanoplyOfProtection_FullLifeCheck)
            endif
        else
            if dmg > HP
                residue = (absorb+HP)-dmg
                // =========================
                debug msg("damage can't be normal absorbed because damage higer than hp")
                debug msg("victim not have full hp")
                debug msg("damage is = "+R2S(dmg))
                debug msg("absorb+hp = "+R2S(HP + absorb))
                debug msg("residue is "+R2S(residue))
                // =========================
                if residue < 0.
                    debug msg("residue lower than 0. Unit must die =(")
                elseif residue > 0.
                    debug msg("residue higer than 0. Absorb shield may be broken!")
                    // =========================
                    SetUnitInvulnerable(need, true)
                    TimerStart(tm, 0.000, false, function ReversVulnerable)
                    SetData(need, GetData(need)-R2I(dmg))
                    if GetData(need) < 0 { SetUnitState(need, UNIT_STATE_LIFE, HP-(dmg - absorb)) }
                endif
            elseif absorb > dmg
                // =========================
                debug msg("damage is = "+R2S(dmg))
                debug msg("absorb is = "+R2S(absorb))
                // =========================
                SetUnitState(need, UNIT_STATE_LIFE, HP+dmg)
                SetData(need, GetData(need)-R2I(dmg))
            elseif absorb < dmg
                SetUnitState(need, UNIT_STATE_LIFE, HP+(dmg - (dmg - absorb)))
                SetData(need, 0)
            endif
        endif
    endif
    
}

// extend true conditions func
void Trig_PanoplyOfProtection_Actions_extend (unit target, int a_lvl){
BuffTimeStruct bts = BuffTimeStruct.new(target, a_lvl)

UnitAddAbility(target,POP_BUFF_SKILL)
someTimer = CreateTimer()
SetData(someTimer, bts)
TimerStart(someTimer, 0.1, true, function BuffTick)
    
    
    if IsUnitInGroup(target, MainGroup)
    else
        GroupAddUnit(MainGroup, target)
        TriggerRegisterUnitEvent(TakeDamage,target,EVENT_UNIT_DAMAGED)
    endif
}

// condition func
function Trig_PanoplyOfProtection_Actions takes nothing returns bool
    if GetSpellAbilityId() == POP_SKILL { Trig_PanoplyOfProtection_Actions_extend (GetSpellTargetUnit(),GetUnitAbilityLevel(GetSpellAbilityUnit(),POP_SKILL)) }
return false
endfunction

//===========================================================================
function InitTrig_PanoplyOfProtection takes nothing returns nothing
    gg_trg_PanoplyOfProtection = CreateTrigger()
    TriggerRegisterAnyUnitEventBJ(gg_trg_PanoplyOfProtection, EVENT_PLAYER_UNIT_SPELL_EFFECT)
    TriggerAddCondition(gg_trg_PanoplyOfProtection, Condition(function Trig_PanoplyOfProtection_Actions))
    
    TriggerAddAction( TakeDamage, function PanoplyOfProtection_MainActions )
    
    TriggerRegisterAnyUnitEventBJ(UselessUnits, EVENT_PLAYER_UNIT_DEATH)
    TriggerAddAction( UselessUnits, function UselessUnits_Actions )
endfunction

endscope