Name | Type | is_array | initial_value |
CP_HiddenItems | item | Yes | |
CP_HiddenItemsIndex | integer | No | |
CP_Item | item | No | |
CP_PointIsWalkable | boolean | No | |
CP_Rect | rect | No | |
IC_Ability | abilcode | No | |
IC_AoE | real | Yes | |
IC_AType | attacktype | No | |
IC_Counter | integer | No | |
IC_DAoE | real | Yes | |
IC_Delay | real | Yes | |
IC_DestroyTree | boolean | No | |
IC_DPS | real | Yes | |
IC_DType | damagetype | No | |
IC_Dummy | unitcode | No | |
IC_EndDamage | real | Yes | |
IC_Flames | integer | Yes | |
IC_Fx1 | string | No | |
IC_Fx2 | string | No | |
IC_Fx3 | string | No | |
IC_HA | hashtable | No | |
IC_iKB_IntelligentTargeting | boolean | No | |
IC_Instances | integer | No | |
IC_MissileFx | string | No | |
IC_Shards | integer | Yes | |
IC_SpreadDamage | real | Yes | |
IC_Target_Allies | boolean | No | |
IC_Target_Magic_Imminue | boolean | No | |
IC_Target_Mechanicals | boolean | No | |
IC_Target_Structures | boolean | No | |
IC_Timer | timer | No | |
IC_XAoE | real | Yes | |
IC_Zoffset | real | Yes | |
KB3D_Accel | real | No | |
KB3D_AllowOutSiding | boolean | No | |
KB3D_Angle | real | No | |
KB3D_AoE | real | No | |
KB3D_AoEDamage | real | No | |
KB3D_AoEEndDamage | real | No | |
KB3D_AoEEndFx | string | No | |
KB3D_AoEKB | boolean | No | |
KB3D_AoEKB_Power | real | No | |
KB3D_Arc | real | No | |
KB3D_Attach | string | No | |
KB3D_AttackType | attacktype | No | |
KB3D_Bounce_Fx | string | No | |
KB3D_Bounce_Power | real | No | |
KB3D_Bounce_Target | boolean | No | |
KB3D_Bounce_Unit | boolean | No | |
KB3D_Counter | integer | No | |
KB3D_D_ALLY | boolean | No | |
KB3D_D_ENEMY | boolean | No | |
KB3D_D_FLYING | boolean | No | |
KB3D_D_MAGIC_IMMINUE | boolean | No | |
KB3D_D_MECHANICAL | boolean | No | |
KB3D_D_RESISTANT | boolean | No | |
KB3D_D_STRUCTURE | boolean | No | |
KB3D_Damager | unit | No | |
KB3D_DamageType | damagetype | No | |
KB3D_DestroyDestructables | boolean | No | |
KB3D_DestroyTree | boolean | No | |
KB3D_DisableUnit | boolean | No | |
KB3D_EndFx | string | No | |
KB3D_EndOnObstacle | boolean | No | |
KB3D_EndTrigger | trigger | No | |
KB3D_EndwhenDead | boolean | No | |
KB3D_EndWhenHit | boolean | No | |
KB3D_FaceAngle | boolean | No | |
KB3D_Fx | string | No | |
KB3D_Fx_Attach | string | No | |
KB3D_g | group | No | |
KB3D_GroundDamage | boolean | No | |
KB3D_Group | group | No | |
KB3D_HA | hashtable | No | |
KB3D_Harvester | unit | No | |
KB3D_iKB | boolean | No | |
KB3D_ImpactDamage | real | No | |
KB3D_Instances | integer | No | |
KB3D_JumpOverCliff | boolean | No | |
KB3D_KBTarget | boolean | No | |
KB3D_KillatEnd | boolean | No | |
KB3D_KillatTime | real | No | |
KB3D_KillifOutSider | boolean | No | |
KB3D_KillWhenHit | boolean | No | |
KB3D_Line_Fx | string | No | |
KB3D_LineDamage | real | No | |
KB3D_LoopDamage | real | No | |
KB3D_Range | real | No | |
KB3D_Reals | real | Yes | |
KB3D_Registration | trigger | No | |
KB3D_Speed | real | No | |
KB3D_StopTime | real | No | |
KB3D_TargetDamage | real | No | |
KB3D_Targeted_Unit | unit | No | |
KB3D_Time | real | No | |
KB3D_Timer | timer | No | |
KB3D_TrailFx | string | No | |
KB3D_Unit | unit | No | |
KB3D_UnpathableStop | boolean | No | |
KB3D_Zoffset | real | No |
//TESH.scrollpos=0
//TESH.alwaysfold=0
/////////////////////////////////////////////////////////////////////////////
// //
// Infernal Cyclone v. 1.3.2.0 [JASS - GUI] //
// by Jad AKA DotCa //
// //
/////////////////////////////////////////////////////////////////////////////
// //
// Credits and others //
// //
// -This Spell uses Knock-Back 3D v. 1.7.1 for it's use, you can //
// choose to not import the KB3D Folder from the test map if //
// and only IF you have the same KB3D version or newer //
// -Credits for WILL THE ALMIGHTY for the FlameThrower Model //
// -Credits for UgoUgo for the OrbofFire Model //
// //
/////////////////////////////////////////////////////////////////////////////
// //
// Importing Process //
// //
// -Make Sure to Import the Icons in the test map for the spell //
// -Check that Create Unknown variables is checked in your WE preferences//
// it can be found in: File --> Preferences --> General //
// -Copy&Paste Infernal Cyclone Folder into your map //
// -If and only IF you haven't the v. 1.7.1 of KB3D or later then CnP the//
// Knock-Back 3D Folder into your map //
// -Create the nessesary dummy unit and import the Models to your map //
// -Configure IC_Dummy and IC_Ability to the right values //
// -Start Using the Spell! //
// //
/////////////////////////////////////////////////////////////////////////////
function IC_Loop takes nothing returns nothing
local real T = 0
local integer i = 1
local unit U
local unit U1
local real x
local real y
local integer ix = 1
local integer level
loop
exitwhen i > udg_IC_Counter
if LoadBoolean(udg_IC_HA, i, 4) then
set T = LoadReal(udg_IC_HA, i, 1)
call SaveReal(udg_IC_HA, i, 1, T - 0.03125)
if T <= 0.03125 then
if LoadBoolean(udg_IC_HA, i, -1) then
set level = LoadInteger(udg_IC_HA, i, 0)
set x = LoadReal(udg_IC_HA, i, 2)
set y = LoadReal(udg_IC_HA, i, 3)
set U1 = LoadUnitHandle(udg_IC_HA, i, 5)
set U = CreateUnit(GetOwningPlayer(U1), udg_IC_Dummy, x, y, 0)
set udg_KB3D_AllowOutSiding = true
set udg_KB3D_Angle = 0
set udg_KB3D_AoE = udg_IC_AoE[level]
set udg_KB3D_AoEEndDamage = udg_IC_EndDamage[level]
set udg_KB3D_DamageType = udg_IC_DType
set udg_KB3D_AttackType = udg_IC_AType
set udg_KB3D_Damager = U1
set udg_KB3D_DestroyTree = udg_IC_DestroyTree
set udg_KB3D_AoEKB = true
set udg_KB3D_Range = 1
set udg_KB3D_Speed = 1/(udg_IC_Delay[level])
set udg_KB3D_Unit = U
set udg_KB3D_UnpathableStop = false
set udg_KB3D_Zoffset = 0
set udg_KB3D_KillatEnd = true
set udg_KB3D_iKB = false
set udg_KB3D_AoEDamage = udg_IC_DPS[level]
set udg_KB3D_D_MAGIC_IMMINUE = udg_IC_Target_Magic_Imminue
set udg_KB3D_D_ALLY = udg_IC_Target_Allies
set udg_KB3D_D_MECHANICAL = udg_IC_Target_Mechanicals
set udg_KB3D_D_STRUCTURE = udg_IC_Target_Structures
call TriggerEvaluate( udg_KB3D_Registration )
//
set U = CreateUnit(GetOwningPlayer(U1), udg_IC_Dummy, x, y, GetRandomReal(0,360))
call SaveEffectHandle(udg_IC_HA, i, 2, AddSpecialEffectTarget(udg_IC_MissileFx, U, "origin"))
call SaveReal(udg_IC_HA, i, 1, udg_IC_Delay[level])
call SaveReal(udg_IC_HA, i, 0, udg_IC_Delay[level])
call SaveReal(udg_IC_HA, i, 6, x)
call SaveReal(udg_IC_HA, i, 7, y)
call SavePlayerHandle(udg_IC_HA, i, 8, GetOwningPlayer(U1))
call SaveInteger(udg_IC_HA, i, 3, level)
call SaveBoolean(udg_IC_HA, i, -1, false)
call SetUnitFlyHeight(U, udg_IC_Zoffset[level], 0)
call SetUnitFlyHeight(U, 0, udg_IC_Zoffset[level]/(udg_IC_Delay[level]))
call SetUnitScale(U, 2, 0, 0)
call UnitApplyTimedLife(U, 'BTLF', udg_IC_Delay[level])
call RemoveSavedHandle(udg_IC_HA, i, 5)
else
set level = LoadInteger(udg_IC_HA, i, 3)
set x = LoadReal(udg_IC_HA, i, 6)
set y = LoadReal(udg_IC_HA, i, 7)
call SaveBoolean(udg_IC_HA, i, 4, false)
call DestroyEffect(LoadEffectHandle(udg_IC_HA, i, 2))
set U = CreateUnit(Player(15), udg_IC_Dummy, x, y, 0)
call SetUnitScale(U, udg_IC_AoE[level]*0.008, 0, 0)
call DestroyEffect(AddSpecialEffectTarget(udg_IC_Fx1, U, "origin"))
call KillUnit(U)
//Boulders
loop
exitwhen ix == udg_IC_Shards[level]
set udg_KB3D_Angle = GetRandomReal(0,360)
set U = CreateUnit(LoadPlayerHandle(udg_IC_HA, i, 8), udg_IC_Dummy, x, y, udg_KB3D_Angle)
set udg_KB3D_AllowOutSiding = true
set udg_KB3D_AoE = udg_IC_DAoE[level]
set udg_KB3D_AoEEndDamage = udg_IC_SpreadDamage[level]
set udg_KB3D_DamageType = udg_IC_DType
set udg_KB3D_AttackType = udg_IC_AType
set udg_KB3D_Damager = U
set udg_KB3D_TrailFx = udg_IC_Fx2
set udg_KB3D_DestroyTree = udg_IC_DestroyTree
set udg_KB3D_Range = GetRandomReal(udg_IC_XAoE[level]/4, udg_IC_XAoE[level])
set udg_KB3D_Speed = 450
set udg_KB3D_Unit = U
set udg_KB3D_D_MAGIC_IMMINUE = udg_IC_Target_Magic_Imminue
set udg_KB3D_D_ALLY = udg_IC_Target_Allies
set udg_KB3D_D_MECHANICAL = udg_IC_Target_Mechanicals
set udg_KB3D_D_STRUCTURE = udg_IC_Target_Structures
set udg_KB3D_UnpathableStop = false
set udg_KB3D_Zoffset = udg_IC_Zoffset[level]/1.5
set udg_KB3D_EndFx = udg_IC_Fx3
set udg_KB3D_KillatEnd = true
set udg_KB3D_iKB = udg_IC_iKB_IntelligentTargeting
call TriggerEvaluate( udg_KB3D_Registration )
set ix = ix + 1
endloop
call FlushChildHashtable(udg_IC_HA, i)
set udg_IC_Instances = udg_IC_Instances - 1
if udg_IC_Instances == 0 then
call PauseTimer(udg_IC_Timer)
set udg_IC_Counter = 0
endif
endif
endif
endif
set i = i + 1
endloop
set U1 = null
set U = null
endfunction
function IC_Cast takes nothing returns boolean
local unit U
local unit u1
local integer level
local integer i
local real x
local real y
if GetSpellAbilityId() == udg_IC_Ability then
set i = 0
set U = GetTriggerUnit()
set level = GetUnitAbilityLevel(U, udg_IC_Ability)
set x = GetSpellTargetX()
set y = GetSpellTargetY()
set udg_IC_Instances = udg_IC_Instances + 1
set udg_IC_Counter = udg_IC_Counter + 1
call SaveInteger(udg_IC_HA, udg_IC_Counter, 0, level)
call SaveReal(udg_IC_HA, udg_IC_Counter, 1, udg_IC_Delay[level])
call SaveReal(udg_IC_HA, udg_IC_Counter, 2, x)
call SaveReal(udg_IC_HA, udg_IC_Counter, 3, y)
call SaveBoolean(udg_IC_HA, udg_IC_Counter, 4, true)
call SaveBoolean(udg_IC_HA, udg_IC_Counter, -1, true)
call SaveUnitHandle(udg_IC_HA, udg_IC_Counter, 5, U)
set u1 = CreateUnit(Player(15), udg_IC_Dummy, x, y, 0)
call SetUnitScale(u1, udg_IC_AoE[level]*0.008, 0, 0)
call DestroyEffect(AddSpecialEffectTarget(udg_IC_Fx1, u1, "origin"))
call KillUnit(u1)
loop
exitwhen i == udg_IC_Flames[level]
//Register the KB3D
set u1 = CreateUnit(GetTriggerPlayer(), udg_IC_Dummy, x, y, 0)
set udg_KB3D_AllowOutSiding = true
set udg_KB3D_Angle = 360/udg_IC_Flames[level] * i
set udg_KB3D_AoE = udg_IC_DAoE[level]
set udg_KB3D_Arc = udg_IC_Delay[level]*4
set udg_KB3D_AoEDamage = udg_IC_DPS[level]
set udg_KB3D_DamageType = udg_IC_DType
set udg_KB3D_AttackType = udg_IC_AType
set udg_KB3D_Damager = U
set udg_KB3D_DestroyTree = udg_IC_DestroyTree
set udg_KB3D_Range = udg_IC_Delay[level]*udg_IC_AoE[level]*2
set udg_KB3D_Speed = udg_IC_AoE[level]
set udg_KB3D_TrailFx = udg_IC_MissileFx
set udg_KB3D_Unit = u1
set udg_KB3D_iKB = udg_IC_iKB_IntelligentTargeting
set udg_KB3D_UnpathableStop = false
set udg_KB3D_Zoffset = udg_IC_Zoffset[level]
set udg_KB3D_KillatTime = udg_IC_Delay[level]
set udg_KB3D_D_MAGIC_IMMINUE = udg_IC_Target_Magic_Imminue
set udg_KB3D_D_ALLY = udg_IC_Target_Allies
set udg_KB3D_D_MECHANICAL = udg_IC_Target_Mechanicals
set udg_KB3D_D_STRUCTURE = udg_IC_Target_Structures
call TriggerEvaluate( udg_KB3D_Registration )
set i = i + 1
endloop
if (udg_IC_Counter == 1) then
call TimerStart(udg_IC_Timer, 0.031250000, true, function IC_Loop )
endif
set U = null
set u1 = null
endif
return false
endfunction
//===========================================================================
function InitTrig_Infernal_Cyclone takes nothing returns nothing
local trigger T = CreateTrigger()
call TriggerRegisterAnyUnitEventBJ(T, EVENT_PLAYER_UNIT_SPELL_EFFECT)
call TriggerAddCondition( T, Condition( function IC_Cast ) )
set udg_IC_HA = InitHashtable()
endfunction
//TESH.scrollpos=0
//TESH.alwaysfold=0
function KB3D_Features_JASS takes nothing returns nothing
// Those Values are Required for the KB
// ------------------------------------------------
// ------------------------
// Knock-Backed Unit, the Knock-Backed Unit who all actions orbit around
set udg_KB3D_Unit = null
// Requires: NONE
// ------------------------
// Max Range, Maximum Range possible of the Knock-Back
set udg_KB3D_Range = 0.00
// Requires: NONE
// ------------------------
// Base KB Speed, Base Speed when starting the Knock-Back
set udg_KB3D_Speed = 0.00
// Requires: NONE
// ------------------------
// Angle, The KB's line angle, this will be useless if KB3D_Targeted_Unit is not null
set udg_KB3D_Angle = 0.00
// Requires: NONE
// ------------------------
// ------------------------------------------------
// Those Values are Optional for the KB
// NOTE: some values may depend on other to function, like LineDamage that needs "Damager, AttackType, DamageType, AoE" to function
// ------------------------------------------------
// ------------------------
// Targets Allowed
// ------------------------
// Filter Damages and AoEKB with those values, if true, each one will allow filtering of Structures, Mechanicals, Magic Imminues, Allies
// ------------------------
set udg_KB3D_D_MAGIC_IMMINUE = false
set udg_KB3D_D_ALLY = false
set udg_KB3D_D_MECHANICAL = false
set udg_KB3D_D_STRUCTURE = false
set udg_KB3D_D_ENEMY = true
set udg_KB3D_D_FLYING = false
set udg_KB3D_D_RESISTANT = false
// Requires: AoEKB, or, Damagers, or, BounceTarget
// ------------------------
// Bounce Unit, Makes the KBed unit bounce on unpathable areas and units
set udg_KB3D_Bounce_Unit = false
// Requires: NONE
// ------------------------
// Bounce Targets, Bounces units that encounter the KBed unit
set udg_KB3D_Bounce_Target = false
// Requires: NONE
// ------------------------
// Bounce Power, intensity of the Bounce
set udg_KB3D_Bounce_Power = 1.00
// Requires: Bounce
// ------------------------
// Bounce Effect, Effect created on units that get Bounced
set udg_KB3D_Bounce_Fx = ""
// Requires: Bounce
// ------------------------
// Destroy Destructibles, Destroys any destructibles on the path of the KB, does not destroy platforms, bridges, elevators
set udg_KB3D_DestroyDestructables = false
// Requires: Line Damage
// ------------------------
// Line Effect, Effect created on units damaged by Line Damage
set udg_KB3D_Line_Fx = ""
// Requires: Line Damage
// ------------------------
// End Trigger, This trigger will be excecuted at the end of the KB, you can use KB3D_Unit and KB3D_Targeted_Unit variables in the trigger
set udg_KB3D_EndTrigger = udg_KB3D_EndTrigger
// Requires: NONE
// ------------------------
// End on Obstacle, Immediatly Ends the KB if the KBed unit encounters an unpathable area
set udg_KB3D_EndOnObstacle = false
// Requires: NONE
// ------------------------
// Arc, Arc of the Angle of the KB, does not work with homing KB
set udg_KB3D_Arc = 0.00
// Requires: Angle
// ------------------------
// Ending Effect, an Effect created at the End of the KB on the KBed Unit
set udg_KB3D_EndFx = ""
// Requires: AoE
// ------------------------
// AoE End Damage, Damage dealt to enemy units in the AoE at the End of the KB
set udg_KB3D_AoEEndDamage = 0.00
// Requires: AoE, Damager, AType, DType
// ------------------------
// AoE KB, if true, KBs Enemy units within the AoE, Range, Speed, Angle, are automatic
set udg_KB3D_AoEKB = false
// Requires: AoE
// ------------------------
// AoE KB Power, The Power of the AoE KB, default value is 1.00 (normal), Min value: 0.01, Max value: 3.00
set udg_KB3D_AoEKB_Power = 0.00
// Requires: AoEKB
// ------------------------
// End when Dead, if true, the KB will end if the KBed unit is dead, TRUE by default
set udg_KB3D_EndwhenDead = true
// Requires: NONE
// ------------------------
// Ground Damage, Damages the Unit When it hits the Ground, Damage dealt is KB3D_ImpactDamage
set udg_KB3D_GroundDamage = false
// Requires: Damager, ImpactDamage, AType, DType
// ------------------------
// KB the Target, When the Targeted Unit is hit, it will be KBed depending on the speed of the original KB
set udg_KB3D_KBTarget = false
// Requires: Targeted_Unit
// ------------------------
// Stop Time, Maximum Time the KB will last, Note that if the KBed unit is flying at this time, it will be stuck
set udg_KB3D_StopTime = 0.00
// Requires: NONE
// ------------------------
// Kill at End, Kills the KBed Unit at the End of the KB
set udg_KB3D_KillatEnd = false
// Requires: NONE
// ------------------------
// Kill at Time, When this time is reached, the KBed unit will be killed, if this number is higher than KB3D_StopTime, EndWhenDead will be automatically turned on no matter what
set udg_KB3D_KillatTime = 0.00
// Requires: NONE
// ------------------------
// Acceleration, Speed Added/s to the KB speed
set udg_KB3D_Accel = 0.00
// Requires: NONE
// ------------------------
// Allow going outside playable bounds, Allows the KBed unit to go out of the Playable Bounds, SAFETY notice: this will not crash the game
set udg_KB3D_AllowOutSiding = false
// Requires: NONE
// ------------------------
// Area of Effect, Range where the Line Damage is applied to units
set udg_KB3D_AoE = 0.00
// Requires: NONE
// ------------------------
// Area of Effect Damage, Makes the KB3D_Damager, damage enemy units within KB3D_AoE by this value as a DPS
set udg_KB3D_AoEDamage = 0.00
// Requires: AoE, Damager, DType, AType
// ------------------------
// Attack Type, Attack type of ALL damagings in the Instance
set udg_KB3D_AttackType = ATTACK_TYPE_MELEE
// Requires: NONE
// ------------------------
// Damage Type, Damage type of ALL damagings in the Instance
set udg_KB3D_DamageType = DAMAGE_TYPE_MAGIC
// Requires: NONE
// ------------------------
// Damager, Source of ALL damagings in the Instance
set udg_KB3D_Damager = null
// Requires: NONE
// ------------------------
// Destroy Trees?, Destroy Trees around the KBed unit while he is KBed?
set udg_KB3D_DestroyTree = true
// Requires: NONE
// ------------------------
// Disable Unit?, Disable the KBed Unit's Movement and Turning?
set udg_KB3D_DisableUnit = false
// Requires: NONE
// ------------------------
// End When Hit?, Ends the KB if the KBed Unit hits the Targeted Unit
set udg_KB3D_EndWhenHit = false
// Requires: Targeted_Unit
// ------------------------
// Face KB Anlge, makes the KBed Unit Face the Anlge of the KB during the KB
set udg_KB3D_FaceAngle = false
// Requires: NONE
// ------------------------
// Effect, Effect created on the Unit's Location if he is not flying, and applied on the Unit if he is flying on the Attach Point
set udg_KB3D_Fx = ""
// Requires: Attach
// ------------------------
// Attachment Point, location on the KBed unit where Effects are attached
set udg_KB3D_Attach = ""
// Requires: NONE
// ------------------------
// AoE End Effect, Effect Created on target units in the AoE at the End of the KB
set udg_KB3D_AoEEndFx = ""
// Requires: AoE, Attach
// ------------------------
// Impact Damage, Damaged dealt to the KBed Unit if he hits an obstacle
set udg_KB3D_ImpactDamage = 0.00
// Requires: Damager
// ------------------------
// intelligent KB, Enables the intelligent features of KB3D, see Main Code Comments for more info
set udg_KB3D_iKB = true
// Requires: NONE
// ------------------------
// Kill When Hit?, Kills the KBed Unit if he hits the Targeted Unit, Automatically set EndWhenHit to true
set udg_KB3D_KillWhenHit = false
// Requires: Targeted_Unit
// ------------------------
// Kill if Out of Playable Bounds, Kills the KBed Unit if he gets out of Playable Bounds, this automatically sets KB3D_AllowOutSiding to TRUE
set udg_KB3D_KillifOutSider = false
// Requires: AllowOutSiding
// ------------------------
// Line Damage, Damage dealt to enemy units in the AoE around the KBed Unit
set udg_KB3D_LineDamage = 0.00
// Requires: Damager, AoE
// ------------------------
// Loop Damage, DPS dealt to the KBed Unit
set udg_KB3D_LoopDamage = 0.00
// Requires: Damager, AoE
// ------------------------
// Jump over Cliff, Allows the KBed unit to go over cliffs if he has more than 150 fly height and IF there is a possible location where he can land in a pathable point, not recommended with >0 Acceleration
set udg_KB3D_JumpOverCliff = false
// Requires: NONE
// ------------------------
// Target Damage, Damage dealt to the Targeted Unit when both KBed Unit and Targeted Unit hit each other, only happens once
set udg_KB3D_TargetDamage = 0.00
// Requires: Targeted_Unit, Damager
// ------------------------
// Targeted Unit, if not null, makes the KBed Unit act like a homing missile targeting this unit, it also used for other functions
set udg_KB3D_Targeted_Unit = null
// Requires: NONE
// ------------------------
// Trail Effect, Effect Attached on the KBed Unit all along the Knock-Back and Destroyed at the end of the KB
set udg_KB3D_TrailFx = ""
// Requires: Attach
// ------------------------
// Stop at Unpathable, Makes it impossible for the KBed Unit to path throught Unpathable Terrain
set udg_KB3D_UnpathableStop = true
// Requires: NONE
// ------------------------
// Z Offset, Max Flying Height reached while Knockbacking
set udg_KB3D_Zoffset = 0.00
// Requires: NONE
// ------------------------
// ------------------------------------------------
// Registed All of the Settings
call TriggerEvaluate( udg_KB3D_Registration )
// You can use the following to know how much the knock-back will last -- this can vary if the KB is homed on a moving unit
set udg_KB3D_Time = udg_KB3D_Time
endfunction
//===========================================================================
function InitTrig_KB3D_Features_JASS takes nothing returns nothing
endfunction
//TESH.scrollpos=0
//TESH.alwaysfold=0
/////////////////////////////////////////////////////////////////////////////
// //
// Knock-Back 3D v. 1.8.3 [JASS - GUI] //
// Multi-Movement System 3D //
// by Jad aka DotCa //
// //
/////////////////////////////////////////////////////////////////////////////
// //
// System's Hidden Features: //
// //
// 1. Use LoadBoolean(udg_KB3D_HA, -1, GetHandleId(Unit)) to know if //
// the unit is being KBed by the system, true value means he is //
// being KBed //
// 2. Use udg_KB3D_Time variable after registring the KB to actually //
// know how much the KB will last, NOTE that this feature is //
// inaccurate if you have a positive acceleration or a Target_Unit //
// 3. Some Variables in the System has default values, but useful; //
// in Example, "udg_KB3D_Attach" is "origin" even without setting //
// it, so you won't need to change it before Registering a KB //
// //
/////////////////////////////////////////////////////////////////////////////
// //
// System Informations: //
// //
// The System is a well performing, ultra-purpose knockback (see uses //
// below ) Coded in JASS making it possible for all users to take //
// advantage of it, and GUI friendly to use, see Examples in the triggers //
// above //
// Configurations that have default values: //
// //
// - KB3D_EndWhenDead ==> TRUE by default //
// - KB3D_UnpathableStop ==> TRUE by default //
// - KB3D_iKB ==> TRUE by default //
// - KB3D_D_ENEMY ==> TRUE by default //
// - KB3D_DestroyTree ==> TRUE by default //
// - KB3D_AttackType ==> ATTACK_TYPE_NORMAL by default //
// - KB3D_DamageType ==> DAMAGE_TYPE_MAGIC by default //
// - KB3D_AoEKB_Power ==> 1.00 by default //
// - KB3D_Fx_Attach ==> "origin" by default //
// - Other Booleans ==> FALSE by default //
// //
// The System also uses Always positive values for some configurations //
// to not make the knockback go wrong, those configurations are: //
// //
// "KB3D_Range" - "KB3D_Speed" - "KB3D_ZOffset" - "KB3D_AoE" //
// //
/////////////////////////////////////////////////////////////////////////////
// //
// iKB, intelligent KB informations: //
// //
// iKB, makes some features in KB3D act intelligently, those features: //
// //
// -Range: usually always positive, it will be available in negative //
// values, it will, if negative, flip the Angle (+180 d) //
// -Speed, usually always positive, it will be available in negative //
// values, it will act normally, just the KBed unit will //
// move backward if the current speed is negative //
// -Damages: //
// AoEEndDamage, AoEDamage, LineDamage, ImpactDamage, TargetDamage //
// //
// All those values ^ will turn intelligent, by this, it means //
// that if the Target of the Damage is not in approximated //
// height (Z) of the KBed Unit, the damage won't occur //
// -AoEKB, usually KBs all units in the AoE, it will choose only //
// Units that are close to it by the height, Z offset //
// //
/////////////////////////////////////////////////////////////////////////////
// //
// System Requirements: Basic WE - (NONE) //
// //
// The System uses implemented CheckWalkability System by PurgeandFire //
// You "can" remove the initialization trigger of PnF's System since //
// it is directly implemented in the System, all will work fine with or //
// without removing your Initializer trigger //
// //
/////////////////////////////////////////////////////////////////////////////
// //
// Credits: //
// //
// *WEHZ & TS Helpers Group for helping in Script Fixes //
// *Barry the Moose for helping in main codes and fixes //
// *PurgeandFire for his CheckWalkability System //
// *Vexorian / Nestharus for the GetCollision function //
// //
/////////////////////////////////////////////////////////////////////////////
// //
// How to Import? //
// //
// 1. Check that Create Unknown Variables is ticked in your WE Settings //
// 2. Copy the Paste the Knock-Back 3D Folder //
// 3. Delete the Variable Creator Trigger and learn how to use the System //
// by reading the documentation in the 2 Features Triggers (GUI - JASS)//
// Congratulations, the System is now implemented in your map //
// //
/////////////////////////////////////////////////////////////////////////////
// //
// How to Use? //
// //
// 1. There are many Examples of use in the KB3D Example Folder //
// 2. Documentations are there in the Features Triggers to help you //
// 3. The KB3D System is an Ultra-Purpose System where you can use it for://
// -Projectiles, the system supports homing so a projectile is easy //
// -Jump, the System's smoothness in the fly is useful for a jump spell//
// -And of course, a 2D Knock-Back //
// -And More depending on your imagination //
// //
/////////////////////////////////////////////////////////////////////////////
// //
// Bug Reports - Feedbacks //
// //
// * We count on you to report bugs in the system, also telling the source//
// * Feedbacks about the system are much appreciated //
// * We mostly hope suggestions about enhancements for the System //
// //
/////////////////////////////////////////////////////////////////////////////
function KB3D_AlwaysNeg takes real R returns real//Used for rendering some values always lower than 0
if R > 0 then
return -R
endif
return R
endfunction
function KB3D_AlwaysPos takes real R returns real//Used for rendering some values always higher than 0
if R < 0 then
return -R
endif
return R
endfunction
function KB3D_InBetween takes real Min, real R, real Max returns real//Used to maintain values between 2 others
return RMaxBJ(RMinBJ(R, Max), Min)
endfunction
function KB3D_IsInBetween takes real Min, real R, real Max returns boolean//Used to maintain values between 2 others
return R > Min and R < Max
endfunction
function KB3D_CW_Loop takes nothing returns nothing//function for item group loop for Check Walkability System
if IsItemVisible(GetEnumItem()) then
set udg_CP_HiddenItems[udg_CP_HiddenItemsIndex] = GetEnumItem()
call SetItemVisible(udg_CP_HiddenItems[udg_CP_HiddenItemsIndex], false)
set udg_CP_HiddenItemsIndex = ( udg_CP_HiddenItemsIndex + 1 )
endif
endfunction
function KB3D_CW takes real x, real y returns boolean//Check Walkability System by PnF
local real x2 = 0
local real y2 = 0
//---------------------------
call MoveRectTo(udg_CP_Rect, x, y)
call EnumItemsInRect(udg_CP_Rect, null, function KB3D_CW_Loop )
call SetItemPosition(udg_CP_Item, x, y)
set x2 = GetItemX(udg_CP_Item)
set y2 = GetItemY(udg_CP_Item)
call SetItemVisible(udg_CP_Item, false)
//---------------------------
loop
exitwhen udg_CP_HiddenItemsIndex == 0
set udg_CP_HiddenItemsIndex = udg_CP_HiddenItemsIndex - 1
call SetItemVisible(udg_CP_HiddenItems[udg_CP_HiddenItemsIndex], true)
set udg_CP_HiddenItems[udg_CP_HiddenItemsIndex] = null
endloop
//---------------------------
return (((x2-x)*(x2-x) + (y2-y)*(y2-y) <= 75) and (not IsTerrainPathable(x, y, PATHING_TYPE_WALKABILITY)))
endfunction
function KB3D_Approx takes unit U, unit U2, integer Loop returns boolean
local real r = KB3D_InBetween(50, LoadReal(udg_KB3D_HA, 29, Loop) / 2, 1000)
local real r1 = GetUnitFlyHeight(U2)
//---------------------------
return KB3D_IsInBetween(r1-r, GetUnitFlyHeight(U), r1+r)
endfunction
function KB3D_Filter takes unit U, unit U1, integer Loop returns boolean
if not IsUnitType(U, UNIT_TYPE_DEAD) then
//---------------------------
if not(LoadBoolean(udg_KB3D_HA, 48, Loop)) and ( IsUnitType(U, UNIT_TYPE_STRUCTURE)) then
return false
elseif not((LoadBoolean(udg_KB3D_HA, 48, Loop)) and ( IsUnitType(U, UNIT_TYPE_STRUCTURE))) then
if not(LoadBoolean(udg_KB3D_HA, 49, Loop)) and ( IsUnitType(U, UNIT_TYPE_MECHANICAL)) then
return false
endif
endif
//---------------------------
if not(LoadBoolean(udg_KB3D_HA, 50, Loop)) and ( IsUnitType(U, UNIT_TYPE_MAGIC_IMMUNE)) then
return false
endif
//---------------------------
if not(LoadBoolean(udg_KB3D_HA, 51, Loop)) and ( IsUnitAlly(U, GetOwningPlayer(U1))) then
return false
endif
//---------------------------
if not(LoadBoolean(udg_KB3D_HA, 63, Loop)) and ( IsUnitEnemy(U, GetOwningPlayer(U1))) then
return false
endif
//---------------------------
if not(LoadBoolean(udg_KB3D_HA, 64, Loop)) and ( IsUnitType(U, UNIT_TYPE_RESISTANT)) then
return false
endif
//---------------------------
if not(LoadBoolean(udg_KB3D_HA, 65, Loop)) and ( IsUnitType(U, UNIT_TYPE_FLYING)) then
return false
endif
//---------------------------
return true
endif
//---------------------------
return false
endfunction
function KB3D_RegisterUnitCollision takes unit u, real x, real y, integer i returns real //Somehow a library for UnitCollision function
local real l = 0
local real h = 300
local real m = 150
local real nm
//---------------------------
loop
if (IsUnitInRangeXY(u, x+m, y, 0)) then
set l = m
else
set h = m
endif
set nm = (l+h)/2
exitwhen nm+.001 > m and nm-.001 < m
set m = nm
endloop
//---------------------------
set m = R2I(m*10)/10.
call SaveReal( udg_KB3D_HA, 16, GetUnitTypeId(u), m )
//---------------------------
return m
endfunction
function KB3D_GetUnitCollision takes unit u returns real//Used to know the collision of a unit //Credits to Netharus// converted by malhorne
local integer i = GetUnitTypeId(u)
//---------------------------
if HaveSavedReal( udg_KB3D_HA, 16, i) then
return LoadReal(udg_KB3D_HA, 16, i)
endif
//---------------------------
return KB3D_RegisterUnitCollision(u, GetUnitX(u), GetUnitY(u), i)
endfunction
function KB3D_Tree_Check takes destructable D returns boolean //Checks if a destructable is a tree
return IssueTargetOrderById( udg_KB3D_Harvester, 852018, D ) and IssueImmediateOrderById(udg_KB3D_Harvester, 851972)
endfunction
function KB3D_KillEnumDest takes nothing returns nothing //Function used in Enumeration loop
local destructable D = GetEnumDestructable()
//---------------------------
if GetDestructableLife(D)>0 and ( KB3D_Tree_Check(D) ) and (GetUnitFlyHeight(LoadUnitHandle(udg_KB3D_HA, 0, R2I(udg_KB3D_Reals[0]))) < GetDestructableOccluderHeight(D)) and LoadBoolean(udg_KB3D_HA, 8, R2I(udg_KB3D_Reals[0])) then
call KillDestructable(D)
elseif not(KB3D_CW(GetDestructableX(D),GetDestructableY(D))) and GetDestructableLife(D)>0 and IssueImmediateOrderById(udg_KB3D_Harvester, 851972) and LoadBoolean(udg_KB3D_HA, 56, R2I(udg_KB3D_Reals[0])) then
call KillDestructable(D)
endif
set D = null
endfunction
function KB3D_CircleTreeKill takes real radius, real x, real y returns nothing//To destroy trees around the unit
local rect r = Rect(x-radius, y-radius, x+radius, y+radius)
//---------------------------
call EnumDestructablesInRect(r, null, function KB3D_KillEnumDest)
//---------------------------
call RemoveRect(r)
set r = null
endfunction
function KB3D_BounceDetection takes unit U, real x, real y returns integer
local group g
//---------------------------
if not KB3D_CW(x,y) then
return 1
endif
//---------------------------
set g = CreateGroup()
call GroupEnumUnitsInRange(g, x, y, KB3D_InBetween(125,KB3D_GetUnitCollision(U)*2.5,999), null)
//---------------------------
if FirstOfGroup(g) != null then
call GroupClear(g)
call DestroyGroup(g)
set g = null
return 2
endif
//---------------------------
call GroupClear(g)
call DestroyGroup(g)
set g = null
return 0
endfunction
function KB3D_Add_Bounce takes unit U, real Angle, real Speed, real Range, boolean UnitBounce, integer Loop returns nothing
set udg_KB3D_Angle = Angle
set udg_KB3D_DestroyTree = LoadBoolean(udg_KB3D_HA, 8, Loop)
set udg_KB3D_Fx = LoadStr(udg_KB3D_HA, 9, Loop)
set udg_KB3D_Attach = LoadStr(udg_KB3D_HA, 10, Loop)
set udg_KB3D_Bounce_Power = LoadReal(udg_KB3D_HA, 59, Loop)
set udg_KB3D_Range = Range*udg_KB3D_Bounce_Power
set udg_KB3D_Speed = Speed/.03125*udg_KB3D_Bounce_Power
set udg_KB3D_Unit = U
set udg_KB3D_Bounce_Unit = UnitBounce
set udg_KB3D_Bounce_Fx = LoadStr(udg_KB3D_HA, 62, Loop)
set udg_KB3D_Accel = LoadReal(udg_KB3D_HA, 4, Loop)
call DestroyEffect(AddSpecialEffect(udg_KB3D_Bounce_Fx, GetUnitX(U), GetUnitY(U)))
if UnitBounce then
set udg_KB3D_Arc = -LoadReal(udg_KB3D_HA, 30, Loop)
set udg_KB3D_EndwhenDead = LoadBoolean(udg_KB3D_HA, 35, Loop)
set udg_KB3D_KillatEnd = LoadBoolean(udg_KB3D_HA, 46, Loop)
set udg_KB3D_FaceAngle = LoadBoolean(udg_KB3D_HA, 31, Loop)
set udg_KB3D_UnpathableStop = LoadBoolean(udg_KB3D_HA, 7, Loop)
endif
if LoadBoolean(udg_KB3D_HA, 57, Loop) then
call SetUnitFlyHeight(U, GetUnitFlyHeight(U)-LoadReal(udg_KB3D_HA, 26, Loop), 750)
endif
call TriggerEvaluate(udg_KB3D_Registration)
call SaveEffectHandle(udg_KB3D_HA, 14, udg_KB3D_Counter, LoadEffectHandle(udg_KB3D_HA, 14, Loop))
endfunction
function KB3D_FilterLoop takes group g, integer Loop returns unit
local unit U = LoadUnitHandle(udg_KB3D_HA, 0, Loop)
local unit u = FirstOfGroup(g)
loop
exitwhen u == null
if KB3D_Filter(u, U, Loop) then
if not(LoadBoolean(udg_KB3D_HA, 44, Loop)) then
set u = null
return FirstOfGroup(g)
elseif KB3D_Approx(u, U, Loop) then
set u = null
return FirstOfGroup(g)
endif
endif
call GroupRemoveUnit(g, u)
endloop
set u = null
return null
endfunction
function KB3D_Bounce takes unit U, real x, real y, integer Loop returns boolean
local unit u
local real Angle
local real Speed
local real Range
//---------------------------
if KB3D_BounceDetection(U,x,y) == 0 then
return false
endif
//---------------------------
if KB3D_BounceDetection(U,x,y) == 1 and LoadBoolean(udg_KB3D_HA, 60, Loop) then
set Angle = LoadReal(udg_KB3D_HA, 5, Loop)*57.29578 + GetRandomReal(-15,15) + 180
set Speed = LoadReal(udg_KB3D_HA, 2, Loop)
set Speed = Speed*.8
set Range = 1.5*Speed/.03125
call KB3D_Add_Bounce(U, Angle, Speed, Range, true, Loop)
return true
endif
//---------------------------
set udg_KB3D_g = CreateGroup()
call GroupEnumUnitsInRange(udg_KB3D_g, x, y, KB3D_InBetween(100,KB3D_GetUnitCollision(U)*2.5,999), null)
if KB3D_BounceDetection(U,x,y) == 2 and KB3D_FilterLoop(udg_KB3D_g, Loop) != null then
set u = KB3D_FilterLoop(udg_KB3D_g, Loop)
set Angle = (Atan2(GetUnitY(u) - GetUnitY(U), GetUnitX(u) - GetUnitX(U)) *57.29578) + GetRandomReal(-15,15) + 180
set Speed = LoadReal(udg_KB3D_HA, 2, Loop)
set Speed = Speed*.8
set Range = 1.5*Speed/.03125
if LoadBoolean(udg_KB3D_HA, 60, Loop) then
call KB3D_Add_Bounce(U, Angle, Speed, Range, true, Loop)
set u = null
call GroupClear(udg_KB3D_g)
call DestroyGroup(udg_KB3D_g)
return true
endif
set Angle = Angle -180
if LoadBoolean(udg_KB3D_HA, 61, Loop) then
call KB3D_Add_Bounce(u, Angle, Speed, Range, false, Loop)
endif
endif
//---------------------------
set u = null
call GroupClear(udg_KB3D_g)
call DestroyGroup(udg_KB3D_g)
return false
endfunction
function KB3D_ClearInstance takes integer i returns nothing
local integer x = 0
//---------------------------
call DestroyGroup(LoadGroupHandle(udg_KB3D_HA, 27, i))
//---------------------------
loop
exitwhen x > 100
call RemoveSavedHandle(udg_KB3D_HA, x, i)
call SaveReal(udg_KB3D_HA, x, i, 0)
set x = x +1
endloop
endfunction
function KB3D_isPossiblePathability takes real x, real y, real RADangle, real MaxDist returns boolean
local real X = x
local real Y = y
local real max = KB3D_AlwaysPos(MaxDist)
local real dist = max
//---------------------------
loop
exitwhen (dist <= 0)
set dist = dist - max/300
set X = x + ( dist * Cos(RADangle) )
set Y = y + ( dist * Sin(RADangle) )
if KB3D_CW(X,Y) then
return true
endif
endloop
//---------------------------
return false
endfunction
function MoveUnit_3D takes unit U, real x, real y, real z, real MaxZ, boolean P, boolean OS, boolean KiOS, real Angle, real S, real time, integer Loop returns boolean
local boolean B = false
local boolean b = true
// This is a creepy place for those who doesn't anylize the system wisely
if LoadBoolean(udg_KB3D_HA, 57, Loop) then
call SetUnitFlyHeight(U, KB3D_InBetween(GetUnitDefaultFlyHeight(U), z, 9999), 0)
endif
//---------------------------
if ( not(P) or ( KB3D_CW(x, y) ) ) then
set B = true
if (OS) then
call SetUnitX(U, KB3D_InBetween(udg_KB3D_Reals[6], x, udg_KB3D_Reals[5]))
call SetUnitY(U, KB3D_InBetween(udg_KB3D_Reals[8], y, udg_KB3D_Reals[7]))
set b = false
if (KiOS) and (not(KB3D_IsInBetween(udg_KB3D_Reals[2], x, udg_KB3D_Reals[1])) or not(KB3D_IsInBetween(udg_KB3D_Reals[4], x, udg_KB3D_Reals[3]))) then
call KillUnit(U)
endif
else
call SetUnitX(U, KB3D_InBetween(udg_KB3D_Reals[2], x, udg_KB3D_Reals[1]))
call SetUnitY(U, KB3D_InBetween(udg_KB3D_Reals[4], y, udg_KB3D_Reals[3]))
set b = false
endif
elseif LoadBoolean(udg_KB3D_HA, 52, Loop) and P and not(KB3D_CW(x, y)) then
if GetUnitFlyHeight(U) >= KB3D_InBetween(128, ( ( GetTerrainCliffLevel(x,y) - GetTerrainCliffLevel(GetUnitX(U),GetUnitY(U)) ) *128 ) , 9999) and (GetTerrainCliffLevel(x,y)-GetTerrainCliffLevel(GetUnitX(U),GetUnitY(U))) <= R2I(GetUnitFlyHeight(U)/128) then
if KB3D_isPossiblePathability(GetUnitX(U),GetUnitY(U), Angle, S*time/0.03125) then
set B = true
call SaveBoolean(udg_KB3D_HA, 53, Loop, true)
if (OS) then
call SetUnitX(U, KB3D_InBetween(udg_KB3D_Reals[6], x, udg_KB3D_Reals[5]))
call SetUnitY(U, KB3D_InBetween(udg_KB3D_Reals[8], y, udg_KB3D_Reals[7]))
set b = false
if (KiOS) and (not(KB3D_IsInBetween(udg_KB3D_Reals[2], x, udg_KB3D_Reals[1])) or not(KB3D_IsInBetween(udg_KB3D_Reals[4], x, udg_KB3D_Reals[3]))) then
call KillUnit(U)
endif
else
call SetUnitX(U, KB3D_InBetween(udg_KB3D_Reals[2], x, udg_KB3D_Reals[1]))
call SetUnitY(U, KB3D_InBetween(udg_KB3D_Reals[4], y, udg_KB3D_Reals[3]))
set b = false
endif
else
call SaveBoolean(udg_KB3D_HA, 52, Loop, false)
endif
endif
endif
if b and LoadBoolean(udg_KB3D_HA, 66, Loop) then
return true
endif
return false
endfunction
function KB3D_LineDamageLoop takes unit U, group g returns nothing
local integer Loop = R2I(udg_KB3D_Reals[0])
local unit Damager = LoadUnitHandle(udg_KB3D_HA, 22, Loop)
local attacktype AType = ConvertAttackType(LoadInteger(udg_KB3D_HA, 20, Loop))
local damagetype DType = ConvertDamageType(LoadInteger(udg_KB3D_HA, 21, Loop))
local real LineD = LoadReal(udg_KB3D_HA, 28, Loop)
local unit U1 = LoadUnitHandle(udg_KB3D_HA, 0, Loop)
local group G = LoadGroupHandle(udg_KB3D_HA, 27, Loop)
//---------------------------
if KB3D_Filter(U, U1, Loop) and not ( IsUnitInGroup(U, G) ) then
call GroupAddUnit(G, U)
if not(LoadBoolean(udg_KB3D_HA, 44, Loop)) then
call UnitDamageTarget(Damager, U, LineD, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
call DestroyEffect(AddSpecialEffectTarget(LoadStr(udg_KB3D_HA, 58, Loop), U, LoadStr(udg_KB3D_HA, 10, Loop)))
elseif KB3D_Approx(U, U1, Loop) then
call UnitDamageTarget(Damager, U, LineD, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
call DestroyEffect(AddSpecialEffectTarget(LoadStr(udg_KB3D_HA, 58, Loop), U, LoadStr(udg_KB3D_HA, 10, Loop)))
endif
endif
//---------------------------
call GroupRemoveUnit(g, U)
//---------------------------
set G = null
set U1 = null
set Damager = null
set AType = null
set DType = null
endfunction
function KB3D_AoEDamageLoop takes unit U, group g returns nothing
local integer Loop = R2I(udg_KB3D_Reals[0])
local unit Damager = LoadUnitHandle(udg_KB3D_HA, 22, Loop)
local attacktype AType = ConvertAttackType(LoadInteger(udg_KB3D_HA, 20, Loop))
local damagetype DType = ConvertDamageType(LoadInteger(udg_KB3D_HA, 21, Loop))
local real AoED = LoadReal(udg_KB3D_HA, 32, Loop)
local unit U1 = LoadUnitHandle(udg_KB3D_HA, 0, Loop)
//---------------------------
if KB3D_Filter(U, U1, Loop) then
if not(LoadBoolean(udg_KB3D_HA, 44, Loop)) then
call UnitDamageTarget(Damager, U, AoED * 0.031250000, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
elseif KB3D_Approx(U, U1, Loop) then
call UnitDamageTarget(Damager, U, AoED * 0.031250000, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
endif
endif
//---------------------------
call GroupRemoveUnit(g, U)
//---------------------------
set U1 = null
set Damager = null
set AType = null
set DType = null
endfunction
function KB3D_AoEEndDamage takes unit U, group g returns nothing
local integer Loop = R2I(udg_KB3D_Reals[0])
local unit Damager = LoadUnitHandle(udg_KB3D_HA, 22, Loop)
local attacktype AType = ConvertAttackType(LoadInteger(udg_KB3D_HA, 20, Loop))
local damagetype DType = ConvertDamageType(LoadInteger(udg_KB3D_HA, 21, Loop))
local real D = LoadReal(udg_KB3D_HA, 38, Loop)
local unit U1 = LoadUnitHandle(udg_KB3D_HA, 0, Loop)
//---------------------------
if KB3D_Filter(U, U1, Loop) then
if not(LoadBoolean(udg_KB3D_HA, 44, Loop)) then
call UnitDamageTarget(Damager, U, D, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
elseif KB3D_Approx(U, U1, Loop) then
call UnitDamageTarget(Damager, U, D, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
endif
endif
//---------------------------
call GroupRemoveUnit(g, U)
//---------------------------
set U1 = null
set Damager = null
set AType = null
set DType = null
endfunction
function KB3D_GiveKBto takes unit U1, unit U2, integer Loop returns nothing
set udg_KB3D_AoEEndDamage = LoadReal(udg_KB3D_HA, 38, Loop)
set udg_KB3D_EndwhenDead = LoadBoolean(udg_KB3D_HA, 35, Loop)
set udg_KB3D_Speed = LoadReal(udg_KB3D_HA, 2, Loop)/0.031250000
set udg_KB3D_Accel = -udg_KB3D_Speed
set udg_KB3D_AllowOutSiding = LoadBoolean(udg_KB3D_HA, 34, Loop)
set udg_KB3D_Angle = (LoadReal(udg_KB3D_HA, 5, Loop)*180/3.14159)
set udg_KB3D_AoE = LoadReal(udg_KB3D_HA, 29, Loop)
set udg_KB3D_AoEDamage = LoadReal(udg_KB3D_HA, 32, Loop)
set udg_KB3D_AttackType = ConvertAttackType(LoadInteger(udg_KB3D_HA, 20, Loop))
set udg_KB3D_DamageType = ConvertDamageType(LoadInteger(udg_KB3D_HA, 21, Loop))
set udg_KB3D_Damager = LoadUnitHandle(udg_KB3D_HA, 22, Loop)
set udg_KB3D_DestroyTree = LoadBoolean(udg_KB3D_HA, 8, Loop)
set udg_KB3D_DisableUnit = LoadBoolean(udg_KB3D_HA, 6, Loop)
set udg_KB3D_FaceAngle = LoadBoolean(udg_KB3D_HA, 31, Loop)
set udg_KB3D_Fx = LoadStr(udg_KB3D_HA, 9, Loop)
set udg_KB3D_Attach = LoadStr(udg_KB3D_HA, 10, Loop)
set udg_KB3D_ImpactDamage = LoadReal(udg_KB3D_HA, 17, Loop)
set udg_KB3D_LineDamage = LoadReal(udg_KB3D_HA, 28, Loop)
set udg_KB3D_LoopDamage = LoadReal(udg_KB3D_HA, 18, Loop)/0.031250000
set udg_KB3D_Range = 99999
set udg_KB3D_Unit = U1
if LoadBoolean(udg_KB3D_HA, 57, Loop) then
set udg_KB3D_Zoffset = LoadReal(udg_KB3D_HA, 3, Loop)/1.85 - GetUnitDefaultFlyHeight(U2)
endif
//---------------------------
call TriggerEvaluate( udg_KB3D_Registration )
endfunction
function KB3D_AoEGiveKBto takes unit U1, unit U2, integer Loop returns nothing
local real x1 = GetUnitX(U1)
local real y1 = GetUnitY(U1)
local real x2 = GetUnitX(U2)
local real y2 = GetUnitY(U2)
local real P = LoadReal(udg_KB3D_HA, 43, Loop)
//---------------------------
set udg_KB3D_AoE = LoadReal(udg_KB3D_HA, 29, Loop)
set udg_KB3D_EndwhenDead = LoadBoolean(udg_KB3D_HA, 35, Loop)
set udg_KB3D_Accel = -550*P
set udg_KB3D_AllowOutSiding = LoadBoolean(udg_KB3D_HA, 34, Loop)
set udg_KB3D_Angle = Atan2(y1 - y2, x1 - x2)*180/3.14159
set udg_KB3D_AoEDamage = LoadReal(udg_KB3D_HA, 32, Loop)
set udg_KB3D_AttackType = ConvertAttackType(LoadInteger(udg_KB3D_HA, 20, Loop))
set udg_KB3D_DamageType = ConvertDamageType(LoadInteger(udg_KB3D_HA, 21, Loop))
set udg_KB3D_Damager = LoadUnitHandle(udg_KB3D_HA, 22, Loop)
set udg_KB3D_DestroyTree = LoadBoolean(udg_KB3D_HA, 8, Loop)
set udg_KB3D_DisableUnit = LoadBoolean(udg_KB3D_HA, 6, Loop)
set udg_KB3D_FaceAngle = LoadBoolean(udg_KB3D_HA, 31, Loop)
set udg_KB3D_Fx = LoadStr(udg_KB3D_HA, 9, Loop)
set udg_KB3D_Attach = LoadStr(udg_KB3D_HA, 10, Loop)
set udg_KB3D_ImpactDamage = LoadReal(udg_KB3D_HA, 17, Loop)
set udg_KB3D_LineDamage = LoadReal(udg_KB3D_HA, 28, Loop)
set udg_KB3D_LoopDamage = LoadReal(udg_KB3D_HA, 18, Loop)/0.031250000
set udg_KB3D_Range = 9999
set udg_KB3D_Speed = udg_KB3D_AoE*2*P
set udg_KB3D_Unit = U1
if LoadBoolean(udg_KB3D_HA, 57, Loop) then
set udg_KB3D_Zoffset = 1.5*(udg_KB3D_AoE - SquareRoot(x2 * x1 + y2 * y1)*3.14159/180)*P
endif
//---------------------------
call TriggerEvaluate( udg_KB3D_Registration )
endfunction
function KB3D_AoEKB takes unit U, group g returns nothing
local integer Loop = R2I(udg_KB3D_Reals[0])
local unit U1 = LoadUnitHandle(udg_KB3D_HA, 0, Loop)
local real r
//---------------------------
if KB3D_Filter(U, U1, Loop) then
if not(LoadBoolean(udg_KB3D_HA, 44, Loop)) then
call KB3D_AoEGiveKBto(U, U1, Loop)
elseif KB3D_Approx(U, U1, Loop) then
call KB3D_AoEGiveKBto(U, U1, Loop)
endif
endif
//---------------------------
call GroupRemoveUnit(g, U)
//---------------------------
set U1 = null
endfunction
function KB3D_AoEEndFx takes unit U, string A, string F, group g returns nothing
local integer Loop = R2I(udg_KB3D_Reals[0])
local unit U1 = LoadUnitHandle(udg_KB3D_HA, 0, Loop)
local real x
local real y
//---------------------------
if KB3D_Filter(U, U1, Loop) and (U != null) then
if not(LoadBoolean(udg_KB3D_HA, 44, Loop)) then
if ( GetUnitFlyHeight(U) > 20 ) then
call DestroyEffect(AddSpecialEffectTarget(F, U, A))
else
set x = GetUnitX(U)
set y = GetUnitY(U)
call DestroyEffect(AddSpecialEffect(F, x, y))
endif
elseif KB3D_Approx(U, U1, Loop) then
if ( GetUnitFlyHeight(U) > 20 ) then
call DestroyEffect(AddSpecialEffectTarget(F, U, A))
else
set x = GetUnitX(U)
set y = GetUnitY(U)
call DestroyEffect(AddSpecialEffect(F, x, y))
endif
endif
endif
//---------------------------
call GroupRemoveUnit(g, U)
//---------------------------
set U1 = null
endfunction
function KB3D_Loop takes integer Loop returns nothing//Main Trigger Loop
//Create all the nessesary locals
local unit U = LoadUnitHandle(udg_KB3D_HA, 0, Loop)
local real X = GetUnitX(U)
local real Y = GetUnitY(U)
local real Z = GetUnitFlyHeight(U)
local real x
local real y
local real z
local real Range = LoadReal(udg_KB3D_HA, 1, Loop)
local real Speed = LoadReal(udg_KB3D_HA, 2, Loop)
local real Zoffset = LoadReal(udg_KB3D_HA, 3, Loop)
local real Accel = LoadReal(udg_KB3D_HA, 4, Loop)
local real Angle
local real ZSpeed = LoadReal(udg_KB3D_HA, 12, Loop)
local real ZAccel = LoadReal(udg_KB3D_HA, 13, Loop)
local real ImpactD = LoadReal(udg_KB3D_HA, 17, Loop)
local real LoopD = LoadReal(udg_KB3D_HA, 18, Loop)
local real TargetD = LoadReal(udg_KB3D_HA, 19, Loop)
local real LineD = LoadReal(udg_KB3D_HA, 28, Loop)
local real AoE = LoadReal(udg_KB3D_HA, 29, Loop)
local real ZT = LoadReal(udg_KB3D_HA, 26, Loop)
local real AoED = LoadReal(udg_KB3D_HA, 32, Loop)
local real Time = LoadReal(udg_KB3D_HA, 41, Loop) + 0.031250000
local real KillatTime = LoadReal(udg_KB3D_HA, 36, Loop)
local real StopTime = LoadReal(udg_KB3D_HA, 37, Loop)
local real AoEEndDamage = LoadReal(udg_KB3D_HA, 38, Loop)
local unit Target = LoadUnitHandle(udg_KB3D_HA, 5, Loop)
local unit Damager = LoadUnitHandle(udg_KB3D_HA, 22, Loop)
local unit u
local boolean DisableUnit = LoadBoolean(udg_KB3D_HA, 6, Loop)
local boolean UnpathableStop = LoadBoolean(udg_KB3D_HA, 7, Loop)
local boolean DestroyTree = LoadBoolean(udg_KB3D_HA, 8, Loop)
local boolean KillWhenHit = LoadBoolean(udg_KB3D_HA, 24, Loop)
local boolean EndWhenHit = LoadBoolean(udg_KB3D_HA, 25, Loop)
local boolean KiOS = LoadBoolean(udg_KB3D_HA, 33, Loop)
local boolean OS = LoadBoolean(udg_KB3D_HA, 34, Loop)
local boolean B = false
local boolean b = false
local boolean b1
local boolean EndwhenDead = LoadBoolean(udg_KB3D_HA, 35, Loop)
local boolean KBTarget = LoadBoolean(udg_KB3D_HA, 39, Loop)
local boolean AoEKB = LoadBoolean(udg_KB3D_HA, 40, Loop)
local boolean KillatEnd = LoadBoolean(udg_KB3D_HA, 46, Loop)
local boolean GroundDamage = LoadBoolean(udg_KB3D_HA, 47, Loop)
local boolean EndB = false
local boolean EndOnObstacle = false
local string Fx = LoadStr(udg_KB3D_HA, 9, Loop)
local string Attach = LoadStr(udg_KB3D_HA, 10, Loop)
local string EndFx = LoadStr(udg_KB3D_HA, 42, Loop)
local string AoEEndFx = LoadStr(udg_KB3D_HA, 54, Loop)
local attacktype AType = ConvertAttackType(LoadInteger(udg_KB3D_HA, 20, Loop))
local damagetype DType = ConvertDamageType(LoadInteger(udg_KB3D_HA, 21, Loop))
local trigger EndT = LoadTriggerHandle(udg_KB3D_HA, 55, Loop)
//end of locals
//Loop Damage Execution
if LoopD != 0 and Damager != null then
call UnitDamageTarget(Damager, U, LoopD, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
endif
//Calculate the Angle
if ( Target == null ) then
set Angle = LoadReal(udg_KB3D_HA, 5, Loop) + LoadReal(udg_KB3D_HA, 30, Loop)//if there is no unit target
else
set Angle = Atan2(GetUnitY(Target) - Y, GetUnitX(Target) - X)//if there is a unit target
endif
//Make Unit Face Angle
if LoadBoolean(udg_KB3D_HA, 31, Loop) then
call SetUnitFacing(U, Angle * (180 / 3.14159))
endif
//Calculate 3D coordinates
set Speed = Speed + ( Accel )//Increase the KB speed depending on the Acceleration
set Range = Range - ( KB3D_AlwaysPos(Speed) )//Decrease distance traveled
set ZSpeed = ZSpeed + ( ZAccel )//change the fly changing rate //Acceleration is for smoothness
set x = X + ( Speed * Cos(Angle) )//new X location of the KBed unit
set y = Y + ( Speed * Sin(Angle) )//new Y location of the KBed unit
set z = Z + ( ZSpeed * 0.031250000 )//new Z Offset of the KBed unit
set ZT = ZT + ( ZSpeed * 0.031250000 )//Total Height Changings
//Destroy Trees around the Unit depending on the unit's Collision Size
if (DestroyTree) or (LoadBoolean(udg_KB3D_HA, 56, Loop)) then
set udg_KB3D_Reals[0] = I2R(Loop)
call KB3D_CircleTreeKill( KB3D_InBetween(150, 4.5 * KB3D_GetUnitCollision(U), 500), x, y )
endif
//Move the unit according to the X, Y, Z
set EndOnObstacle = MoveUnit_3D(U, x, y, z, Zoffset, UnpathableStop, OS, KiOS, Angle, Speed, LoadReal(udg_KB3D_HA, 11, Loop)-Time, Loop)
//Create the Effect on the unit
if (Fx != "") then
if ( z > 20 ) then
if (Attach != "") then
call DestroyEffect(AddSpecialEffectTarget(Fx, U, Attach))//attach the effect on the unit if he is flying
endif
else
call DestroyEffect(AddSpecialEffect(Fx, x, y))//create the effect on his location if he is not flying
endif
endif
//Initiate Impact Damage
if ( (UnpathableStop) and not ( KB3D_CW(x, y) ) ) and ( (ImpactD != 0) and (Damager != null ) ) then//if the terrain is unpathable or if unpathable stop is disabled then..
if ( KB3D_CW(x, y) ) then
call SaveBoolean(udg_KB3D_HA, 23, Loop, true)
endif
if ( LoadBoolean(udg_KB3D_HA, 23, Loop) ) then
call UnitDamageTarget(Damager, U, ImpactD, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)//Apply Impact Damage to the unit
call SaveBoolean(udg_KB3D_HA, 23, Loop, false)
endif
endif
//Initiate Line Damage
if (LineD != 0) and (Damager != null) and (AoE != 0) then
set udg_KB3D_g = CreateGroup()
set udg_KB3D_Reals[0] = I2R(Loop)
call GroupEnumUnitsInRange(udg_KB3D_g, x, y, KB3D_AlwaysPos(AoE), null)
loop
set u = FirstOfGroup(udg_KB3D_g)
call KB3D_LineDamageLoop(u, udg_KB3D_g)
exitwhen (u == null)
endloop
call DestroyGroup(udg_KB3D_g)
set udg_KB3D_g = null
endif
//Initiate AoE Damage
if (AoED != 0) and (Damager != null) and (AoE != 0) then
set udg_KB3D_g = CreateGroup()
set udg_KB3D_Reals[0] = I2R(Loop)
call GroupEnumUnitsInRange(udg_KB3D_g, x, y, KB3D_AlwaysPos(AoE), null)
loop
set u = FirstOfGroup(udg_KB3D_g)
call KB3D_AoEDamageLoop(u, udg_KB3D_g)
exitwhen (u == null)
endloop
call DestroyGroup(udg_KB3D_g)
set udg_KB3D_g = null
endif
//Disable the unit partially
if ( DisableUnit ) then
call SetUnitPropWindow(U, 0)
call SetUnitTurnSpeed(U, 0)
endif
//Initiate Bounce Feature
if LoadBoolean(udg_KB3D_HA, 61, Loop) or LoadBoolean(udg_KB3D_HA, 60, Loop) then
call SaveReal(udg_KB3D_HA, 67, Loop, LoadReal(udg_KB3D_HA, 67, Loop)-0.03125)
if LoadReal(udg_KB3D_HA, 67, Loop) == 0 then
call SaveReal(udg_KB3D_HA, 67, Loop, 0.15625)
set EndB = KB3D_Bounce(U, x, y, Loop)
endif
endif
//Initiate Target-Related Actions
if (Target != null) then
if (SquareRoot ( ( GetUnitX(Target) - x ) * ( GetUnitX(Target) - x ) + ( GetUnitY(Target) - y ) * ( GetUnitY(Target) - y ) ) < Speed+2) then//when the target and the unit are close
if not (TargetD == 0) and not(Damager == null) then//Damage the Target
call UnitDamageTarget(Damager, Target, TargetD, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
call SaveReal(udg_KB3D_HA, 19, Loop, 0)
endif
if KBTarget then//KB the Target
call KB3D_GiveKBto(Target, U, Loop)
call SaveBoolean( udg_KB3D_HA, 39, udg_KB3D_Counter, false )
endif
if (KillWhenHit) then//Kill the Unit
call KillUnit(U)
endif
if (EndWhenHit) then//End the KB
call SaveReal(udg_KB3D_HA, 4, Loop, KB3D_AlwaysNeg(Speed))
call SaveReal(udg_KB3D_HA, 3, Loop, GetUnitFlyHeight(U) - ZT)
endif
endif
endif
//Kill the Unit at the time
if (KillatTime != 0) and ( Time > KillatTime ) then
call KillUnit(U)
endif
//set B to if Stop time is exceeded
set B = ( (StopTime != 0) and ( Time > StopTime ) )
//iKB interference
set b1 = LoadBoolean(udg_KB3D_HA, 45, Loop) and (Speed <= 0)
//Save Changes in the Hashtable
call SaveReal(udg_KB3D_HA, 1, Loop, Range)
call SaveReal(udg_KB3D_HA, 2, Loop, Speed)
call SaveReal(udg_KB3D_HA, 5, Loop, Angle)
call SaveReal(udg_KB3D_HA, 12, Loop, ZSpeed)
call SaveReal(udg_KB3D_HA, 26, Loop, ZT)
call SaveReal(udg_KB3D_HA, 41, Loop, Time)
//Inititate End of the KB
if ( b1 or ( Range <= 0 ) or ( B ) or EndB or EndOnObstacle ) then
call SaveBoolean(udg_KB3D_HA, 100, Loop, false)
set udg_KB3D_Instances = udg_KB3D_Instances - 1
if IsUnitType(U, UNIT_TYPE_DEAD) then
call SetUnitFlyHeight(U, GetUnitDefaultFlyHeight(U), 750 )
endif
call SetUnitPropWindow(U, LoadReal(udg_KB3D_HA, 15, Loop)*3.14159/180)
call SetUnitTurnSpeed(U, GetUnitDefaultTurnSpeed(U))
if HaveSavedHandle(udg_KB3D_HA, 14, Loop) and not EndB then
call DestroyEffect(LoadEffectHandle(udg_KB3D_HA, 14, Loop))
endif
call SaveBoolean(udg_KB3D_HA, -1, GetHandleId(U), false)
set b = true
elseif IsUnitType(U, UNIT_TYPE_DEAD) and (EndwhenDead) then
call SaveBoolean(udg_KB3D_HA, 100, Loop, false)
set udg_KB3D_Instances = udg_KB3D_Instances - 1
if IsUnitType(U, UNIT_TYPE_DEAD) then
call SetUnitFlyHeight(U, GetUnitDefaultFlyHeight(U), 750 )
endif
call SetUnitPropWindow(U, LoadReal(udg_KB3D_HA, 15, Loop)*3.14159/180)
call SetUnitTurnSpeed(U, GetUnitDefaultTurnSpeed(U))
if HaveSavedHandle(udg_KB3D_HA, 14, Loop) and not EndB then
call DestroyEffect(LoadEffectHandle(udg_KB3D_HA, 14, Loop))
endif
call SaveBoolean(udg_KB3D_HA, -1, GetHandleId(U), false)
set b = true
endif
//variable b refers to if the KB has ended
//AoE damage at the end of the KB
if (b) and (AoEEndDamage != 0) and (Damager != null) and (AoE != 0) then
set udg_KB3D_g = CreateGroup()
set udg_KB3D_Reals[0] = I2R(Loop)
call GroupEnumUnitsInRange(udg_KB3D_g, x, y, KB3D_AlwaysPos(AoE), null)
loop
set u = FirstOfGroup(udg_KB3D_g)
call KB3D_AoEEndDamage(u, udg_KB3D_g)
exitwhen (u == null)
endloop
call DestroyGroup(udg_KB3D_g)
set udg_KB3D_g = null
endif
//AoE Knock-back at the end of the KB
if (b) and (AoEKB) and (AoE != 0) then
set udg_KB3D_g = CreateGroup()
set udg_KB3D_Reals[0] = I2R(Loop)
call GroupEnumUnitsInRange(udg_KB3D_g, x, y, KB3D_AlwaysPos(AoE), null)
loop
set u = FirstOfGroup(udg_KB3D_g)
call KB3D_AoEKB(u, udg_KB3D_g)
exitwhen (u == null)
endloop
call DestroyGroup(udg_KB3D_g)
set udg_KB3D_g = null
endif
//Create End Effect
if b and (EndFx != "") then
if ( z > 20 ) and (Attach != "") then
call DestroyEffect(AddSpecialEffectTarget(EndFx, U, Attach))//attach the effect on the unit if he is flying
else
call DestroyEffect(AddSpecialEffect(EndFx, x, y))//create the effect on his location if he is not flying
endif
endif
//Create AoE End Fx
if b and (AoEEndFx != "") and (Attach != "") and (AoE > 0) then
set udg_KB3D_g = CreateGroup()
set udg_KB3D_Reals[0] = I2R(Loop)
call GroupEnumUnitsInRange(udg_KB3D_g, x, y, KB3D_AlwaysPos(AoE), null)
loop
set u = FirstOfGroup(udg_KB3D_g)
call KB3D_AoEEndFx(u, Attach, AoEEndFx, udg_KB3D_g)
exitwhen (u == null)
endloop
call DestroyGroup(udg_KB3D_g)
set udg_KB3D_g = null
endif
//Ground Damage
if b and GroundDamage and (ImpactD != 0) and z < 75 and (Damager != null) then
call UnitDamageTarget(Damager, U, ImpactD, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
endif
//Kill at End
if b and (KillatEnd) and not EndB then
call KillUnit(U)
endif
//End Trigger Execution
if b and (EndT != null) then
set udg_KB3D_Unit = U
set udg_KB3D_Targeted_Unit = Target
call ConditionalTriggerExecute(EndT)
set udg_KB3D_Unit = null
set udg_KB3D_Targeted_Unit = null
endif
//Function to know if the unit is being KBed by the system
call SaveInteger(udg_KB3D_HA, -2, GetHandleId(udg_KB3D_Unit), LoadInteger(udg_KB3D_HA, -2, GetHandleId(udg_KB3D_Unit))-1)
call SaveBoolean(udg_KB3D_HA, -1, GetHandleId(udg_KB3D_Unit), LoadInteger(udg_KB3D_HA, -2, GetHandleId(udg_KB3D_Unit))!=0)
//Clear Instance
if b then
call KB3D_ClearInstance(Loop)
endif
//Clear locals
set U = null
set Target = null
set Damager = null
endfunction
function KB3D_Loop_Actions takes nothing returns nothing//loop triggerer
local integer x = 0
loop
exitwhen x >= udg_KB3D_Counter
set x = x + 1
if ( LoadBoolean(udg_KB3D_HA, 100, x) ) then
call KB3D_Loop(x)
endif
endloop
if ( udg_KB3D_Instances == 0 ) then
set udg_KB3D_Counter = 0
call PauseTimer(udg_KB3D_Timer)
endif
endfunction
function KB3D_ClearVar takes nothing returns nothing
set udg_KB3D_AoEEndFx = ""
set udg_KB3D_D_STRUCTURE = false
set udg_KB3D_D_MECHANICAL = false
set udg_KB3D_D_ALLY = false
set udg_KB3D_D_MAGIC_IMMINUE = false
set udg_KB3D_D_ENEMY = true
set udg_KB3D_D_RESISTANT = false
set udg_KB3D_D_FLYING = false
set udg_KB3D_Accel = 0.00
set udg_KB3D_AllowOutSiding = false
set udg_KB3D_Angle = 0.00
set udg_KB3D_AoE = 0.00
set udg_KB3D_Arc = 0.00
set udg_KB3D_AoEDamage = 0.00
set udg_KB3D_AttackType = ATTACK_TYPE_NORMAL
set udg_KB3D_DamageType = DAMAGE_TYPE_MAGIC
set udg_KB3D_Damager = null
set udg_KB3D_DestroyTree = true
set udg_KB3D_DisableUnit = false
set udg_KB3D_EndWhenHit = false
set udg_KB3D_Fx = ""
set udg_KB3D_EndFx = ""
set udg_KB3D_Attach = "origin"
set udg_KB3D_ImpactDamage = 0.00
set udg_KB3D_KillWhenHit = false
set udg_KB3D_FaceAngle = false
set udg_KB3D_KillifOutSider = false
set udg_KB3D_LineDamage = 0.00
set udg_KB3D_LoopDamage = 0.00
set udg_KB3D_Range = 0.00
set udg_KB3D_Speed = 0.00
set udg_KB3D_TargetDamage = 0.00
set udg_KB3D_Targeted_Unit = null
set udg_KB3D_TrailFx = ""
set udg_KB3D_Unit = null
set udg_KB3D_UnpathableStop = true
set udg_KB3D_Zoffset = 0.00
set udg_KB3D_AoEEndDamage = 0.00
set udg_KB3D_AoEKB = false
set udg_KB3D_EndwhenDead = true
set udg_KB3D_KBTarget = false
set udg_KB3D_StopTime = 0.00
set udg_KB3D_KillatTime = 0.00
set udg_KB3D_AoEKB_Power = 1.00
set udg_KB3D_iKB = true
set udg_KB3D_KillatEnd = false
set udg_KB3D_GroundDamage = false
set udg_KB3D_EndTrigger = null
set udg_KB3D_JumpOverCliff = false
set udg_KB3D_DestroyDestructables = false
set udg_KB3D_Line_Fx = ""
set udg_KB3D_Bounce_Target = false
set udg_KB3D_Bounce_Unit = false
set udg_KB3D_Bounce_Power = 1.00
set udg_KB3D_Bounce_Fx = ""
set udg_KB3D_EndOnObstacle = false
endfunction
function KB3D_Registration takes nothing returns boolean//register an instance in the System
local real Time
local real R
local real R1
set udg_KB3D_Arc = KB3D_InBetween(-10, udg_KB3D_Arc, 10)
set udg_KB3D_AoEKB_Power = KB3D_InBetween(0.01, udg_KB3D_AoEKB_Power, 3)
if IsUnitType(udg_KB3D_Unit, UNIT_TYPE_FLYING) then
set udg_KB3D_UnpathableStop = false
endif
if (udg_KB3D_iKB) and udg_KB3D_Range < 0 then
if ( udg_KB3D_Targeted_Unit == null ) then
set udg_KB3D_Angle = udg_KB3D_Angle + 180
else
set udg_KB3D_Speed = -1*(udg_KB3D_Speed)
endif
endif
set udg_KB3D_Range = KB3D_InBetween(0.0000001, KB3D_AlwaysPos(udg_KB3D_Range), KB3D_AlwaysPos(udg_KB3D_Range))
if (udg_KB3D_iKB) and udg_KB3D_Speed < 0 then
set udg_KB3D_Speed = KB3D_InBetween(udg_KB3D_Speed, udg_KB3D_Speed, -0.01)
else
set udg_KB3D_Speed = KB3D_InBetween(0.01, KB3D_AlwaysPos(udg_KB3D_Speed), KB3D_AlwaysPos(udg_KB3D_Speed))
endif
set udg_KB3D_Counter = udg_KB3D_Counter + 1
set udg_KB3D_Instances = udg_KB3D_Instances + 1
call SaveBoolean(udg_KB3D_HA, -1, GetHandleId(udg_KB3D_Unit), true)
call SaveBoolean(udg_KB3D_HA, 57, udg_KB3D_Counter, (udg_KB3D_Zoffset > 0))
set udg_KB3D_Zoffset = (1.85 * KB3D_AlwaysPos(udg_KB3D_Zoffset)) + GetUnitDefaultFlyHeight(udg_KB3D_Unit)
set udg_KB3D_StopTime = KB3D_AlwaysPos(udg_KB3D_StopTime)
set udg_KB3D_KillatTime = KB3D_AlwaysPos(udg_KB3D_KillatTime)
set udg_KB3D_AoE = KB3D_AlwaysPos(udg_KB3D_AoE)
call SaveUnitHandle( udg_KB3D_HA, 0, udg_KB3D_Counter, udg_KB3D_Unit )
call SaveReal( udg_KB3D_HA, 1, udg_KB3D_Counter, udg_KB3D_Range )
call SaveReal( udg_KB3D_HA, 2, udg_KB3D_Counter, udg_KB3D_Speed * 0.031250000 )
call SaveReal( udg_KB3D_HA, 4, udg_KB3D_Counter, udg_KB3D_Accel * 0.031250000 * 0.031250000 )
if ( udg_KB3D_Targeted_Unit == null ) then
call SaveReal( udg_KB3D_HA, 5, udg_KB3D_Counter, udg_KB3D_Angle * 3.14159 / 180 )
else
call SaveUnitHandle( udg_KB3D_HA, 5, udg_KB3D_Counter, udg_KB3D_Targeted_Unit )
set udg_KB3D_JumpOverCliff = false
endif
call SaveBoolean( udg_KB3D_HA, 6, udg_KB3D_Counter, udg_KB3D_DisableUnit )
call SaveBoolean( udg_KB3D_HA, 7, udg_KB3D_Counter, udg_KB3D_UnpathableStop )
call SaveBoolean( udg_KB3D_HA, 8, udg_KB3D_Counter, udg_KB3D_DestroyTree )
call SaveStr( udg_KB3D_HA, 9, udg_KB3D_Counter, udg_KB3D_Fx )
call SaveStr( udg_KB3D_HA, 10, udg_KB3D_Counter, udg_KB3D_Attach )
call SaveBoolean( udg_KB3D_HA, 45, udg_KB3D_Counter, udg_KB3D_Speed>0 )
set udg_KB3D_Speed = KB3D_InBetween(0.01, KB3D_AlwaysPos(udg_KB3D_Speed), KB3D_AlwaysPos(udg_KB3D_Speed))
if ( udg_KB3D_Accel == 0.00 ) then
set Time = udg_KB3D_Range / (udg_KB3D_Speed)//calculating time for the knockback if Acceleration = 0
else
if ( udg_KB3D_Accel > 0 ) then
set Time = (( -2*(udg_KB3D_Speed) + SquareRoot((4*udg_KB3D_Speed*udg_KB3D_Speed) + (8*udg_KB3D_Accel*udg_KB3D_Range ) ) / (2*udg_KB3D_Accel) ))//calculating time for the knockback if Acceleration > 0
endif
if ( udg_KB3D_Accel < 0 ) then
set R = ( - 1 * (udg_KB3D_Speed) / udg_KB3D_Accel )
set R1 = (0.5 * udg_KB3D_Accel * R * R) + ((udg_KB3D_Speed) * R)
if R1 < udg_KB3D_Range then
set Time = R//calculating time for the knockback if Acceleration < 0 and if the speed will be = 0 before reaching max range
else
set Time = KB3D_AlwaysPos(( -2*(udg_KB3D_Speed) + SquareRoot(KB3D_AlwaysPos((4*(udg_KB3D_Speed)*(udg_KB3D_Speed)) + (8*udg_KB3D_Accel*udg_KB3D_Range) )) ) / (2*udg_KB3D_Accel) )//calculating time for the knockback if Acceleration < 0 and if the speed will be > 0 before reaching max range
endif
endif
endif
call SaveReal( udg_KB3D_HA, 11, udg_KB3D_Counter, Time )
call SaveBoolean( udg_KB3D_HA, 100, udg_KB3D_Counter, true )
if UnitAddAbility(udg_KB3D_Unit, 'Amrf') then
call UnitRemoveAbility(udg_KB3D_Unit, 'Amrf')
endif
call SaveReal( udg_KB3D_HA, 3, udg_KB3D_Counter, udg_KB3D_Zoffset )
call SaveReal( udg_KB3D_HA, 12, udg_KB3D_Counter, (udg_KB3D_Zoffset / ( Time / 2)) )
call SaveReal( udg_KB3D_HA, 13, udg_KB3D_Counter, ( -1 * udg_KB3D_Zoffset / ( Time / 2) ) / ( Time / 2) * 0.031250000 )
if not (udg_KB3D_TrailFx == "") and not (udg_KB3D_Attach == "") then
call SaveEffectHandle(udg_KB3D_HA, 14, udg_KB3D_Counter, AddSpecialEffectTarget(udg_KB3D_TrailFx, udg_KB3D_Unit, udg_KB3D_Attach))
endif
call SaveReal( udg_KB3D_HA, 15, udg_KB3D_Counter, GetUnitDefaultPropWindow(udg_KB3D_Unit) )
call SaveReal( udg_KB3D_HA, 17, udg_KB3D_Counter, udg_KB3D_ImpactDamage )
call SaveReal( udg_KB3D_HA, 18, udg_KB3D_Counter, udg_KB3D_LoopDamage * 0.031250000 )
call SaveReal( udg_KB3D_HA, 19, udg_KB3D_Counter, udg_KB3D_TargetDamage )
call SaveInteger( udg_KB3D_HA, 20, udg_KB3D_Counter, GetHandleId(udg_KB3D_AttackType))
call SaveInteger( udg_KB3D_HA, 21, udg_KB3D_Counter, GetHandleId(udg_KB3D_DamageType))
call SaveUnitHandle( udg_KB3D_HA, 22, udg_KB3D_Counter, udg_KB3D_Damager )
call SaveBoolean( udg_KB3D_HA, 23, udg_KB3D_Counter, true )
call SaveBoolean( udg_KB3D_HA, 24, udg_KB3D_Counter, udg_KB3D_KillWhenHit )
call SaveBoolean( udg_KB3D_HA, 25, udg_KB3D_Counter, udg_KB3D_EndWhenHit )
call SaveGroupHandle(udg_KB3D_HA, 27, udg_KB3D_Counter, CreateGroup() )
call SaveReal( udg_KB3D_HA, 28, udg_KB3D_Counter, udg_KB3D_LineDamage )
call SaveReal( udg_KB3D_HA, 29, udg_KB3D_Counter, KB3D_AlwaysPos(udg_KB3D_AoE) )
call SaveReal( udg_KB3D_HA, 30, udg_KB3D_Counter, udg_KB3D_Arc * (3.14159/180) )
call SaveBoolean( udg_KB3D_HA, 31, udg_KB3D_Counter, udg_KB3D_FaceAngle )
call SaveReal( udg_KB3D_HA, 32, udg_KB3D_Counter, udg_KB3D_AoEDamage )
call SaveBoolean( udg_KB3D_HA, 33, udg_KB3D_Counter, udg_KB3D_KillifOutSider )
set udg_KB3D_AllowOutSiding = udg_KB3D_KillifOutSider
call SaveBoolean( udg_KB3D_HA, 34, udg_KB3D_Counter, udg_KB3D_AllowOutSiding )
set udg_KB3D_EndwhenDead = udg_KB3D_KillatTime > udg_KB3D_StopTime
call SaveBoolean( udg_KB3D_HA, 35, udg_KB3D_Counter, udg_KB3D_EndwhenDead )
call SaveReal( udg_KB3D_HA, 36, udg_KB3D_Counter, udg_KB3D_KillatTime )
call SaveReal( udg_KB3D_HA, 37, udg_KB3D_Counter, udg_KB3D_StopTime )
call SaveReal( udg_KB3D_HA, 38, udg_KB3D_Counter, udg_KB3D_AoEEndDamage )
call SaveBoolean( udg_KB3D_HA, 39, udg_KB3D_Counter, udg_KB3D_KBTarget )
call SaveBoolean( udg_KB3D_HA, 40, udg_KB3D_Counter, udg_KB3D_AoEKB )
//41 used
call SaveStr(udg_KB3D_HA, 42, udg_KB3D_Counter, udg_KB3D_EndFx )
call SaveReal( udg_KB3D_HA, 43, udg_KB3D_Counter, udg_KB3D_AoEKB_Power )
call SaveBoolean( udg_KB3D_HA, 44, udg_KB3D_Counter, udg_KB3D_iKB )
call SaveBoolean( udg_KB3D_HA, 46, udg_KB3D_Counter, udg_KB3D_KillatEnd )
call SaveBoolean( udg_KB3D_HA, 47, udg_KB3D_Counter, udg_KB3D_GroundDamage )
call SaveBoolean( udg_KB3D_HA, 48, udg_KB3D_Counter, udg_KB3D_D_STRUCTURE )
call SaveBoolean( udg_KB3D_HA, 49, udg_KB3D_Counter, udg_KB3D_D_MECHANICAL )
call SaveBoolean( udg_KB3D_HA, 50, udg_KB3D_Counter, udg_KB3D_D_MAGIC_IMMINUE )
call SaveBoolean( udg_KB3D_HA, 51, udg_KB3D_Counter, udg_KB3D_D_ALLY )
call SaveBoolean( udg_KB3D_HA, 52, udg_KB3D_Counter, udg_KB3D_JumpOverCliff )
call SaveBoolean( udg_KB3D_HA, 53, udg_KB3D_Counter, false )
call SaveStr( udg_KB3D_HA, 54, udg_KB3D_Counter, udg_KB3D_AoEEndFx )
call SaveTriggerHandle( udg_KB3D_HA, 55, udg_KB3D_Counter, udg_KB3D_EndTrigger )
call SaveBoolean( udg_KB3D_HA, 56, udg_KB3D_Counter, udg_KB3D_DestroyDestructables )
//57 used
call SaveStr( udg_KB3D_HA, 58, udg_KB3D_Counter, udg_KB3D_Line_Fx )
call SaveReal( udg_KB3D_HA, 59, udg_KB3D_Counter, udg_KB3D_Bounce_Power )
call SaveBoolean( udg_KB3D_HA, 60, udg_KB3D_Counter, udg_KB3D_Bounce_Unit )
call SaveBoolean( udg_KB3D_HA, 61, udg_KB3D_Counter, udg_KB3D_Bounce_Target )
call SaveStr( udg_KB3D_HA, 62, udg_KB3D_Counter, udg_KB3D_Bounce_Fx )
call SaveBoolean( udg_KB3D_HA, 63, udg_KB3D_Counter, udg_KB3D_D_ENEMY )
call SaveBoolean( udg_KB3D_HA, 64, udg_KB3D_Counter, udg_KB3D_D_RESISTANT )
call SaveBoolean( udg_KB3D_HA, 65, udg_KB3D_Counter, udg_KB3D_D_FLYING )
call SaveBoolean( udg_KB3D_HA, 66, udg_KB3D_Counter, udg_KB3D_EndOnObstacle )
call SaveReal( udg_KB3D_HA, 67, udg_KB3D_Counter, 0.15625 )
//Nulling
call KB3D_ClearVar()
//
if ( udg_KB3D_Counter == 1 ) then
call TimerStart(udg_KB3D_Timer, 0.031250000, true, function KB3D_Loop_Actions )
endif
set udg_KB3D_Time = Time
call SaveInteger(udg_KB3D_HA, -2, GetHandleId(udg_KB3D_Unit), LoadInteger(udg_KB3D_HA, -2, GetHandleId(udg_KB3D_Unit))+1)
call SaveBoolean(udg_KB3D_HA, -1, GetHandleId(udg_KB3D_Unit), true)
return false
endfunction
//===========================================================================
function InitTrig_KB3D takes nothing returns nothing
////////REGISTRATION
set udg_KB3D_Registration = CreateTrigger( )
call TriggerAddCondition( udg_KB3D_Registration, Condition(function KB3D_Registration) )
set udg_KB3D_Harvester = CreateUnit(Player(15), 'hpea', 0, 0, 0)
call ShowUnit(udg_KB3D_Harvester, false)
call UnitAddAbility(udg_KB3D_Harvester, 'Aloc')
call UnitAddAbility(udg_KB3D_Harvester, 'Ahar')
call UnitRemoveAbility(udg_KB3D_Harvester, 'Amov')
set udg_KB3D_HA = InitHashtable()
////////Check Walkability System by PnF
set udg_CP_Rect = Rect(0, 0, 128.00, 128.00)
set udg_CP_Item = CreateItem('wtlg', 0, 0)
call SetItemVisible( udg_CP_Item, false )
////////InitReals
set udg_KB3D_Reals[1] = GetRectMaxX(bj_mapInitialPlayableArea)
set udg_KB3D_Reals[2] = GetRectMinX(bj_mapInitialPlayableArea)
set udg_KB3D_Reals[3] = GetRectMaxY(bj_mapInitialPlayableArea)
set udg_KB3D_Reals[4] = GetRectMinY(bj_mapInitialPlayableArea)
set udg_KB3D_Reals[5] = GetRectMaxX(GetWorldBounds())
set udg_KB3D_Reals[6] = GetRectMinX(GetWorldBounds())
set udg_KB3D_Reals[7] = GetRectMaxY(GetWorldBounds())
set udg_KB3D_Reals[8] = GetRectMinY(GetWorldBounds())
//Initiate Default Values
call KB3D_ClearVar()
endfunction