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 | |
IS_Ability | abilcode | No | |
IS_Caster | unit | Yes | |
IS_CasterPosition | location | No | |
IS_ChanceEffect | integer | No | |
IS_ChanceLeadEffect | integer | No | |
IS_CollideUnit | unit | No | |
IS_CollideUnitEffect | string | No | |
IS_CollideUnitEffectAttach | string | No | |
IS_CollideUnitPosition | location | No | |
IS_CurrentIndex | integer | No | |
IS_DummyImpaleAbility | abilcode | No | |
IS_DummyStunAbility | abilcode | No | |
IS_DummyUnitImpalePosition | location | No | |
IS_DummyUnitType | unitcode | No | |
IS_GroupContainer | group | Yes | |
IS_ImpactAttackType | attacktype | No | |
IS_ImpactDamage | real | Yes | |
IS_ImpactDamageType | damagetype | No | |
IS_ImpactDummyUnit | unit | No | |
IS_ImpactEffect | string | No | |
IS_ImpactImpaleUnit | unit | No | |
IS_ImpactRadius | real | Yes | |
IS_ImpactScaleRatio | real | No | |
IS_ImpaleAngle | real | Yes | |
IS_ImpaleAttackType | attacktype | No | |
IS_ImpaleBonusRange | real | Yes | |
IS_ImpaleCollisionDamage | real | Yes | |
IS_ImpaleCollisionSize | real | Yes | |
IS_ImpaleDamageType | damagetype | No | |
IS_ImpaleDummyUnit | unit | Yes | |
IS_ImpaleDummyUnitImpaleCaster | unit | No | |
IS_ImpaleDummyUnitPosition | location | No | |
IS_ImpaleDummyUnitStunCaster | unit | No | |
IS_ImpaleEffect | string | No | |
IS_ImpaleEffectDummyUnit | unit | No | |
IS_ImpaleEffectSize | real | Yes | |
IS_ImpaleLeadDummyUnit | unit | No | |
IS_ImpaleLeadEffect | string | No | |
IS_ImpaleLeadSize | real | Yes | |
IS_ImpaleMovementLocation | location | No | |
IS_ImpaleRangeDistance | real | Yes | |
IS_ImpaleReleaseAngle | real | No | |
IS_ImpaleReleaseLocation | location | No | |
IS_ImpaleReleaseOffsetFactor | real | Yes | |
IS_ImpaleScaleRatio | real | No | |
IS_ImpaleSpeed | real | Yes | |
IS_ImpaleSpeedCalculation | real | Yes | |
IS_ImpaleSpeedCounter | real | Yes | |
IS_KB_Acceleration | real | Yes | |
IS_KB_AllowThroughBorders | boolean | No | |
IS_KB_AttackType | attacktype | No | |
IS_KB_DamageType | damagetype | No | |
IS_KB_DestroyTree | boolean | No | |
IS_KB_DisableUnit | boolean | No | |
IS_KB_LoopDamage | real | Yes | |
IS_KB_LoopEffect | string | No | |
IS_KB_LoopEffectAttach | string | No | |
IS_KB_MaxHeight | real | Yes | |
IS_KB_Range | real | Yes | |
IS_KB_Speed | real | Yes | |
IS_KB_TrailEffect | string | No | |
IS_KB_UnitCollision | real | Yes | |
IS_KB_UnpathableStop | boolean | No | |
IS_Level | integer | Yes | |
IS_MaxIndex | integer | No | |
IS_PickedUnit | unit | No | |
IS_PickedUnitPosition | location | No | |
IS_Player | player | Yes | |
IS_SecondaryImpaleReleaseTime | real | Yes | |
IS_SecondaryImpaleTimeCounter | real | Yes | |
IS_TargetLocation | location | Yes | |
KB3D_Accel | real | No | |
KB3D_AllowOutSiding | boolean | No | |
KB3D_Angle | real | No | |
KB3D_AoE | real | No | |
KB3D_AoEDamage | real | No | |
KB3D_Arc | real | No | |
KB3D_AttackType | attacktype | No | |
KB3D_Counter | integer | No | |
KB3D_Damager | unit | No | |
KB3D_DamageType | damagetype | No | |
KB3D_DestroyTree | boolean | No | |
KB3D_DisableUnit | boolean | No | |
KB3D_EndWhenHit | boolean | No | |
KB3D_FaceAngle | boolean | No | |
KB3D_Fx | string | No | |
KB3D_Fx_Attach | string | No | |
KB3D_Group | group | No | |
KB3D_HA | hashtable | No | |
KB3D_Harvester | unit | No | |
KB3D_ImpactDamage | real | No | |
KB3D_Instances | integer | No | |
KB3D_KillifOutSider | boolean | No | |
KB3D_KillWhenHit | boolean | 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_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=139
//TESH.alwaysfold=0
/////////////////////////////////////////////////////////////////////////////
// //
// Knock-Back 3D v. 1.4.2 [JASS - GUI] //
// by JAD aka DotCa //
// //
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// //
// 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 have default values: //
// //
// - KB3D_DestroyTree ==> FALSE by default //
// - KB3D_DisableUnit ==> FALSE by default //
// - KB3D_UnpathaableStop ==> TRUE by default //
// - KB3D_AttackType ==> ATTACK_TYPE_NORMAL //
// - KB3D_DamageType ==> DAMAGE_TYPE_MAGIC //
// //
// The System also uses Always positive values for some configurations //
// to not make the knockback go worng, those configurations are: //
// //
// "KB3D_Range" - "KB3D_Speed" - "KB3D_ZOffset" //
// //
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// //
// 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 //
// *Rheiko for Beta Stages Testings //
// //
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// //
// How to Import? //
// //
// 1. Check that Create Unknown Variables is ticked in your WE Settings //
// 2. Copy the Paste this Trigger //
// 3. Congratulations, the System is now implemented in your map //
// //
/////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////
// //
// How to Use? //
// //
// 1. There are 3 Examples of use in the KB3D Example Folder //
// 2. Documentations are there in each of the 5 examples 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 SaveAttackTypeHandle takes hashtable hash, integer parentKey, integer childKey, attacktype at returns nothing
call SaveInteger(hash, parentKey, childKey, GetHandleId(at))
endfunction
function LoadAttackTypeHandle takes hashtable hash, integer parentKey, integer childKey returns attacktype
return ConvertAttackType(LoadInteger(hash, parentKey, childKey))
endfunction
function SaveDamageTypeHandle takes hashtable hash, integer parentKey, integer childKey, damagetype dt returns nothing
call SaveInteger(hash, parentKey, childKey, GetHandleId(dt))
endfunction
function LoadDamageTypeHandle takes hashtable hash, integer parentKey, integer childKey returns damagetype
return ConvertDamageType(LoadInteger(hash, parentKey, childKey))
endfunction
function KB3D_AlwaysNeg takes real R returns real//Used for redering some values always lower than 0
if R > 0 then
set R = R * -1
endif
return R
endfunction
function KB3D_AlwaysPos takes real R returns real//Used for redering some values always higher than 0
if R < 0 then
set R = R * -1
endif
return R
endfunction
function KB3D_InBetween takes real Min, real R, real Max returns real//Used to maintain values between 2 others
if R < Min then
set R = Min
elseif R > Max then
set R = Max
endif
return R
endfunction
function KB3D_IsInBetween takes real Min, real R, real Max returns boolean//Used to maintain values between 2 others
if R < Min then
return false
elseif R > Max then
return false
endif
return true
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
local boolean B
set B = IssueTargetOrder( udg_KB3D_Harvester, "harvest", D )
call IssueImmediateOrder(udg_KB3D_Harvester, "stop")
return B
endfunction
function KB3D_KillifTree takes destructable D returns nothing //Kills a destructable if it is a tree
if ( KB3D_Tree_Check(D) ) then
call KillDestructable(D)
endif
endfunction
function KB3D_KillEnumDest takes nothing returns nothing //Function used in Enumeration loop
call KB3D_KillifTree(GetEnumDestructable())
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_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
set udg_CP_PointIsWalkable = ((x2-x)*(x2-x) + (y2-y)*(y2-y) <= 100) and (not IsTerrainPathable(x, y, PATHING_TYPE_WALKABILITY))
return udg_CP_PointIsWalkable
endfunction
function KB3D_ClearInstance takes integer i returns nothing
local integer x = 0
call DestroyGroup(LoadGroupHandle(udg_KB3D_HA, 27, i))
loop
exitwhen x > 34
call RemoveSavedHandle(udg_KB3D_HA, x, i)
call SaveReal(udg_KB3D_HA, x, i, 0)
set x = x +1
endloop
endfunction
function MoveUnit_3D takes unit U, real x, real y, real z, real MaxZ, boolean B, boolean end, boolean OS, boolean KiOS returns nothing
if (end) then
call SetUnitFlyHeight(U, KB3D_InBetween(GetUnitDefaultFlyHeight(U), z, MaxZ), 750)
else
call SetUnitFlyHeight(U, KB3D_InBetween(GetUnitDefaultFlyHeight(U), z, MaxZ), 0)
endif
if ( not(B) or ( KB3D_CW(x, y) ) or (OS) ) then
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]))
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]))
endif
endif
endfunction
function KB3D_LineDamageLoop takes nothing returns boolean
local unit U = GetFilterUnit()
local integer Loop = R2I(udg_KB3D_Reals[0])
local unit Damager = LoadUnitHandle(udg_KB3D_HA, 22, Loop)
local attacktype AType = LoadAttackTypeHandle(udg_KB3D_HA, 20, Loop)
local damagetype DType = LoadDamageTypeHandle(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 ( not( IsUnitType(U, UNIT_TYPE_STRUCTURE) ) and not( IsUnitType(U, UNIT_TYPE_MECHANICAL) ) and( IsUnitEnemy(U, GetOwningPlayer(U1))) and not ( IsUnitInGroup(U, G) ) ) then
call GroupAddUnit(G, U)
call UnitDamageTarget(Damager, U, LineD, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
endif
set G = null
set U = null
set U1 = null
set Damager = null
return false
endfunction
function KB3D_AoEDamageLoop takes nothing returns boolean
local unit U = GetFilterUnit()
local integer Loop = R2I(udg_KB3D_Reals[0])
local unit Damager = LoadUnitHandle(udg_KB3D_HA, 22, Loop)
local attacktype AType = LoadAttackTypeHandle(udg_KB3D_HA, 20, Loop)
local damagetype DType = LoadDamageTypeHandle(udg_KB3D_HA, 21, Loop)
local real AoED = LoadReal(udg_KB3D_HA, 32, Loop)
local unit U1 = LoadUnitHandle(udg_KB3D_HA, 0, Loop)
if ( not( IsUnitType(U, UNIT_TYPE_STRUCTURE) ) and not( IsUnitType(U, UNIT_TYPE_MECHANICAL) ) and( IsUnitEnemy(U, GetOwningPlayer(U1))) ) then
call UnitDamageTarget(Damager, U, AoED * 0.031250000, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
endif
set U = null
set U1 = null
set Damager = null
return false
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 unit Target = LoadUnitHandle(udg_KB3D_HA, 5, Loop)
local unit Damager = LoadUnitHandle(udg_KB3D_HA, 22, Loop)
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 string Fx = LoadStr(udg_KB3D_HA, 9, Loop)
local string Attach = LoadStr(udg_KB3D_HA, 10, Loop)
local attacktype AType = LoadAttackTypeHandle(udg_KB3D_HA, 20, Loop)
local damagetype DType = LoadDamageTypeHandle(udg_KB3D_HA, 21, Loop)
local group g
//end of locals
if not (LoopD == 0) and not (Damager == null ) then//damage target with loop damage
call UnitDamageTarget(Damager, U, LoopD, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
endif
if ( Target == null ) then//know the angle of knockback line
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
if LoadBoolean(udg_KB3D_HA, 31, Loop) then
call SetUnitFacing(U, Angle * (180 / 3.14159))
endif
set Speed = Speed + ( Accel )//Increase the KB speed depending on the Acceleration
set Range = Range - ( 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
if ( (Speed <= 0) or ( Range <= 0 ) or ( GetWidgetLife(U) <= 0 ) ) then
set B = true
endif
call MoveUnit_3D(U, x, y, z, Zoffset, UnpathableStop, B, OS, KiOS)//Move the unit according to the X, Y, Z
if (DestroyTree) then//Check if Destroy Tree is enabled
call KB3D_CircleTreeKill( KB3D_InBetween(100, 4 * KB3D_GetUnitCollision(U), 500), x, y )//Destroy trees around target
endif
if not (Fx == "") then//create an effect on the unit
if ( z > 20 ) then
if not (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
if ( (UnpathableStop) and not ( KB3D_CW(x, y) ) ) and (not (ImpactD == 0) and not (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
if not(LineD == 0) and not(Damager == null) and not(AoE == 0) then//LineDamage
set g = CreateGroup()
set udg_KB3D_Reals[0] = I2R(Loop)
call GroupEnumUnitsInRange(udg_KB3D_Group, x, y, KB3D_AlwaysPos(AoE), Filter(function KB3D_LineDamageLoop))
call DestroyGroup(g)
set g = null
endif
if not(AoED == 0) and not(Damager == null) and not(AoE == 0) then//LoopDamage
set g = CreateGroup()
set udg_KB3D_Reals[0] = I2R(Loop)
call GroupEnumUnitsInRange(udg_KB3D_Group, x, y, KB3D_AlwaysPos(AoE), Filter(function KB3D_AoEDamageLoop))
call DestroyGroup(g)
set g = null
endif
if ( DisableUnit ) then//disable the unit partially
call SetUnitPropWindow(U, 0)
call SetUnitTurnSpeed(U, 0)
endif
if not(Target == null) then
if (SquareRoot ( ( GetUnitX(Target) - x ) * ( GetUnitX(Target) - x ) + ( GetUnitY(Target) - y ) * ( GetUnitY(Target) - y ) ) < KB3D_InBetween(75, KB3D_GetUnitCollision(U) + KB3D_GetUnitCollision(Target), 999)) then
if not (TargetD == 0) and not(Damager == null) then
call UnitDamageTarget(Damager, Target, TargetD, true, false, AType, DType, WEAPON_TYPE_WHOKNOWS)
call SaveReal(udg_KB3D_HA, 19, Loop, 0)
endif
if (KillWhenHit) then
call KillUnit(U)
endif
if (EndWhenHit) then
call SaveReal(udg_KB3D_HA, 4, Loop, KB3D_AlwaysNeg(Speed))
call SaveReal(udg_KB3D_HA, 3, Loop, GetUnitFlyHeight(U) - ZT)
endif
endif
endif
////// Stop All
if ( (Speed <= 0) or ( Range <= 0 ) or ( GetWidgetLife(U) <= 0 ) ) then
call SaveBoolean(udg_KB3D_HA, 55, Loop, false)
set udg_KB3D_Instances = udg_KB3D_Instances - 1
if ( GetWidgetLife(U) <= 0 ) 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) then
call DestroyEffect(LoadEffectHandle(udg_KB3D_HA, 14, Loop))
endif
call KB3D_ClearInstance(Loop)
else
////// Save Changes
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)
endif
////// Clear
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, 55, 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_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_Range = KB3D_InBetween(0.01, KB3D_AlwaysPos(udg_KB3D_Range), KB3D_AlwaysPos(udg_KB3D_Range))
set udg_KB3D_Speed = KB3D_InBetween(0.01, KB3D_AlwaysPos(udg_KB3D_Speed), KB3D_AlwaysPos(udg_KB3D_Speed))
set udg_KB3D_Counter = udg_KB3D_Counter + 1
set udg_KB3D_Instances = udg_KB3D_Instances + 1
set udg_KB3D_Zoffset = (1.85 * KB3D_AlwaysPos(udg_KB3D_Zoffset))+GetUnitDefaultFlyHeight(udg_KB3D_Unit)
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 )
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_Fx_Attach )
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) + (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, 55, 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, KB3D_AlwaysNeg(( -1 * udg_KB3D_Zoffset / ( Time / 2) ) / ( Time / 2)) * 0.031250000 )
if not (udg_KB3D_TrailFx == "") and not (udg_KB3D_Fx_Attach == "") then
call SaveEffectHandle(udg_KB3D_HA, 14, udg_KB3D_Counter, AddSpecialEffectTarget(udg_KB3D_TrailFx, udg_KB3D_Unit, udg_KB3D_Fx_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 SaveAttackTypeHandle( udg_KB3D_HA, 20, udg_KB3D_Counter, udg_KB3D_AttackType )
call SaveDamageTypeHandle( udg_KB3D_HA, 21, udg_KB3D_Counter, 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 )
if (udg_KB3D_KillWhenHit) then
set udg_KB3D_EndWhenHit = true
endif
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 )
if (udg_KB3D_KillifOutSider) then
set udg_KB3D_AllowOutSiding = true
endif
call SaveBoolean( udg_KB3D_HA, 34, udg_KB3D_Counter, udg_KB3D_AllowOutSiding )
//Nulling
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 = false
set udg_KB3D_DisableUnit = false
set udg_KB3D_EndWhenHit = false
set udg_KB3D_Fx = ""
set udg_KB3D_Fx_Attach = ""
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
if ( udg_KB3D_Counter == 1 ) then
call TimerStart(udg_KB3D_Timer, 0.031250000, true, function KB3D_Loop_Actions )
endif
set udg_KB3D_Time = Time
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')
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())
endfunction
//TESH.scrollpos=0
//TESH.alwaysfold=0
*Spell Name: Mega Impale Shock v1.0 = Initial Upload.
*Spell Author/Creator: by jakeZinc.
*Spell Version: v1.0 = * Initial Released.
*Spell Purpose: Uses KB3D System v1.4.2 ( Highly Recommended )
Useful from reducing outnumbered armies and it is high range that can chase some enemies
Can knockback the targeted area and releasing impales in random angle per mini second.
*Spell Idea: None.
*Spell Requested: None.
*Spell Features v1.0 = * Multi- Unit Instanceabilty ( MUI Spell )
* Lagless
* Leakles
How to Import/Install:
=Preparing for import=
Go to:
File
Preferences
General
Check the box labelled ''Automatically create unknown variables while pasting trigger data''
=Speeding up import of object data-
Go to:
Window
make sure the 'brush list' is unchecked.
You can swap between my map and your map.
=Main importing=
Difficuly in Importing:
"Easy" = 1 to 3 Copy - Paste Required
"Medium" = 4 to 6 Copy - Paste Required
"Hard" = 7 above, Copy - Paste Required
Spell Importing Difficulty: 'Hard'
In order of importing: Copy --> Paste to your Map.
Object Data (OE) - Spell - Impale Shock - Ability
Object Data (OE) - Spell - Impale Shock - DummyStunAbility
Object Data (OE) - Spell - Impale Shock - DummyImpaleAbility
Object Data (OE) - Unit - Impale Shock - Dummy Unit
Trigger Data (TE) - Folder - IS - Impale Shock
Trigger Data (TE) - Folder - KnockBack 3D
Import/Export Files:
You must import the dummy model by Vexorian in Import Manager ( F12 )
* Notes:
Note #1: Make sure to Configure the " IS Configuration " trigger in the IS_Ability and IS_DummyUnit.
Note #2: IF your map has already KnockBack 3D System then dont copy the KnockBack 3D System.
Note #3: If the impact model effect didnt show up in the spell then make sure that you copy the "IS Dummy" in your
map and make sure you import the Dummy Model by Vexorian.
Note #4: Report to the Author If you found a bug or tell the author if the spell is not working.
Note #5: The spell will work if you follow the notes and the Main Importing Instructions.
Note #6: Enjoy
=Modification=
All Modifications should be done in the Configuration Trigger, each configuration is explained and elaborated.
//==========================================================================================================================================
Pls Give credits if you use this spell in your map.
Credits: Vexorian ( Dummy.mdl )
Credits: Jad ( KB3D System v1.4.2 )
Sincerely,
jakeZinc