library Haunt initializer Init requires Global

    globals
        // ====================
        private constant integer SkillId                = 'A003'    // ID of skill
        private constant integer SkillRealityId         = 'A004'    // ID of Reality skill
        private constant integer DummyId                = 'h000'    // ID of dummy caster
        private constant integer DummyCastId            = 'S000'    // ID of dummy Illusion ability
        private constant integer DummyCastOrder         = 852274    // Order of dummy Illusion ability
        // ====================
        private constant integer MAXLVL = 3                         // Levels of skill
        private constant real array IllusionDuration[MAXLVL]        // Illusion duration
    endglobals
    
    // ===============================================================
    
    globals
        public key SkillKey
        // ====================
        private real    TEMP_X
        private real    TEMP_Y
        private real    TEMP_Distance
        private unit    TEMP_Illusion
        private unit    TEMP_Caster
        private trigger TEMP_Trigger
    endglobals
    
    struct Haunt_illusion
        unit Target
        unit Illusion
        private trigger Trigger
        
        private static method Function takes nothing returns boolean
            local thistype this = LoadInteger(Global_Hash, GetHandleId(GetTriggeringTrigger()), SkillKey)
            if GetTriggerEventId() == EVENT_UNIT_SUMMON then
                set .Illusion = GetSummonedUnit()
                call SetUnitPathing(.Illusion, false)
                call SetUnitMoveSpeed(.Illusion, 400)
                call SetUnitX(.Illusion, GetUnitX(.Target))
                call SetUnitY(.Illusion, GetUnitY(.Target))
                call IssueTargetOrder(.Illusion, "attack", .Target)
                call SaveInteger(Global_Hash, GetHandleId(.Illusion), SkillKey, this)
                call TriggerRegisterTimerEvent(.Trigger, 0.025, true)
                call TriggerRegisterUnitEvent(.Trigger, .Illusion, EVENT_UNIT_DEATH)
                call TriggerRegisterUnitEvent(.Trigger, .Illusion, EVENT_UNIT_ISSUED_ORDER)
                call TriggerRegisterUnitEvent(.Trigger, .Illusion, EVENT_UNIT_ISSUED_TARGET_ORDER)
                call TriggerRegisterUnitEvent(.Trigger, .Illusion, EVENT_UNIT_ISSUED_POINT_ORDER)
            elseif GetTriggerEventId() == EVENT_GAME_TIMER_EXPIRED or GetTriggerEventId() == EVENT_UNIT_ISSUED_ORDER or GetTriggerEventId() == EVENT_UNIT_ISSUED_TARGET_ORDER or GetTriggerEventId() == EVENT_UNIT_ISSUED_POINT_ORDER then
                call DisableTrigger(.Trigger)
                call IssueTargetOrder(.Illusion, "attack", .Target)
                call EnableTrigger(.Trigger)
            else
                this.destroy()
            endif
            return false
        endmethod
        
        method executeReality takes unit c returns nothing
            local real x = GetUnitX(c)
            local real y = GetUnitY(c)
            call SetUnitX(c, GetUnitX(.Illusion))
            call SetUnitY(c, GetUnitY(.Illusion))
            call SetUnitX(.Illusion, x)
            call SetUnitY(.Illusion, y)
            call IssueTargetOrder(c, "attack", .Target)
        endmethod
        
        static method create takes unit c, unit t, trigger trg returns thistype
            local thistype this = thistype.allocate()
            local unit dummy
            set .Target = t
            // ====================
            set dummy = CreateUnit(Player(PLAYER_NEUTRAL_PASSIVE), DummyId, GetUnitX(.Target), GetUnitY(.Target), 0)
            set .Trigger = CreateTrigger()
            call SaveInteger(Global_Hash, GetHandleId(.Trigger), SkillKey, this)
            call TriggerAddCondition(.Trigger, Condition(function thistype.Function))
            call TriggerRegisterUnitEvent(.Trigger, .Target, EVENT_UNIT_DEATH)
            call TriggerRegisterUnitEvent(.Trigger, dummy, EVENT_UNIT_SUMMON)
            call TriggerRegisterUnitEvent(trg, dummy, EVENT_UNIT_SUMMON)
            call UnitAddAbility(dummy, DummyCastId)
            call SetUnitAbilityLevel(dummy, DummyCastId, GetUnitAbilityLevel(c, SkillId))
            call IssueTargetOrderById(dummy, DummyCastOrder, c)
            call UnitApplyTimedLife(dummy, 0, 1)
            set dummy = null
            return this
        endmethod
        method destroy takes nothing returns nothing
            call DisableTrigger(.Trigger)
            call FlushChildHashtable(Global_Hash, GetHandleId(.Trigger))
            call DestroyTrigger(.Trigger)
            set .Trigger = null
            // ====================
            call KillUnit(.Illusion)
            set .Target = null
            set .Illusion = null
            call this.deallocate()
        endmethod
    endstruct
    
    struct Haunt
        unit Caster
        group GroupIllusion
        private trigger Trigger
        
        private static method Function takes nothing returns boolean
            local thistype this = LoadInteger(Global_Hash, GetHandleId(GetTriggeringTrigger()), SkillKey)
            local Haunt_illusion h_i
            if GetTriggerEventId() == EVENT_UNIT_SPELL_EFFECT then
                if GetSpellAbilityId() == SkillRealityId then
                    set TEMP_X = GetSpellTargetX()
                    set TEMP_Y = GetSpellTargetY()
                    set TEMP_Distance = 99999
                    set TEMP_Illusion = null
                    call ForGroup(.GroupIllusion, function thistype.NearbyIllusionEnum)
                    if TEMP_Illusion != null then
                        set h_i = LoadInteger(Global_Hash, GetHandleId(TEMP_Illusion), SkillKey)
                        call h_i.executeReality(.Caster)
                    endif
                endif
            elseif GetTriggerEventId() == EVENT_UNIT_SUMMON then
                call SetUnitOwner(GetSummonedUnit(), GetOwningPlayer(.Caster), true)
                call GroupAddUnit(.GroupIllusion, GetSummonedUnit())
            else
                this.destroy()
            endif
            return false
        endmethod
        
        private static method NearbyIllusionEnum takes nothing returns nothing
            local real d = DistanceBetweenWidgetAndCoords(GetEnumUnit(), TEMP_X, TEMP_Y)
            if not IsUnitDead(GetEnumUnit()) and d <= TEMP_Distance then
                TEMP_Distance = d
                TEMP_Illusion = GetEnumUnit() 
            endif
        endmethod
        private static method IllusionForTargetFilter takes nothing returns boolean
            if IsUnitType(GetFilterUnit(), UNIT_TYPE_HERO) and IsUnitEnemy(GetFilterUnit(), GetOwningPlayer(TEMP_Caster)) then
                call Haunt_illusion.create(TEMP_Caster, GetFilterUnit(), TEMP_Trigger)
            endif
            return false
        endmethod
        
        static method create takes unit c returns thistype
            local thistype this = thistype.allocate()
            set .Caster = c
            set .GroupIllusion = CreateGroup()
            // ====================
            set .Trigger = CreateTrigger()
            call SaveInteger(Global_Hash, GetHandleId(.Trigger), SkillKey, this)
            call TriggerAddCondition(.Trigger, Condition(function thistype.Function))
            call TriggerRegisterTimerEvent(.Trigger, IllusionDuration[GetUnitAbilityLevel(.Caster, SkillId)], false)
            call TriggerRegisterUnitEvent(.Trigger, .Caster, EVENT_UNIT_SPELL_EFFECT)
            set TEMP_Caster = .Caster
            set TEMP_Trigger = .Trigger
            call GroupEnumUnitsInRect(Global_TempGroup, bj_mapInitialPlayableArea, Condition(function thistype.IllusionForTargetFilter))
            return this
        endmethod
        method destroy takes nothing returns nothing
            call DisableTrigger(.Trigger)
            call FlushChildHashtable(Global_Hash, GetHandleId(.Trigger))
            call DestroyTrigger(.Trigger)
            set .Trigger = null
            // ====================
            call DestroyGroup(.GroupIllusion)
            set .Caster = null
            set .GroupIllusion = null
            call this.deallocate()
        endmethod
    endstruct
    
       
    private function SkillAction_EFFECT takes nothing returns nothing
        call Haunt.create(GetTriggerUnit())
    endfunction
    private function SkillCondition_EFFECT takes nothing returns boolean
        return GetSpellAbilityId() == SkillId
    endfunction
    
    private function SkillAction_LEARN takes nothing returns nothing
        call UnitAddAbility(GetTriggerUnit(), SkillRealityId)
        call SetUnitAbilityLevel(GetTriggerUnit(), SkillRealityId, GetLearnedSkillLevel())
        call UnitMakeAbilityPermanent(GetTriggerUnit(), true, SkillRealityId)
    endfunction
    private function SkillCondition_LEARN takes nothing returns boolean
        return GetLearnedSkill() == SkillId
    endfunction
    
    private function Init takes nothing returns nothing
        local trigger trg = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ(trg, EVENT_PLAYER_HERO_SKILL)
        call TriggerAddCondition(trg, Condition(function SkillCondition_LEARN))
        call TriggerAddAction(trg, function SkillAction_LEARN)
        set trg = CreateTrigger()
        call TriggerRegisterAnyUnitEventBJ(trg, EVENT_PLAYER_UNIT_SPELL_EFFECT)
        call TriggerAddCondition(trg, Condition(function SkillCondition_EFFECT))
        call TriggerAddAction(trg, function SkillAction_EFFECT)
        set trg = null
        // ====================
        set IllusionDuration[1] = 4
        set IllusionDuration[2] = 5
        set IllusionDuration[3] = 6
    endfunction
    
endlibrary