Name | Type | is_array | initial_value |
//TESH.scrollpos=0
//TESH.alwaysfold=0
library TimerUtils initializer init
//*********************************************************************
//* TimerUtils (red+blue+orange flavors for 1.24b+)
//* ----------
//*
//* To implement it , create a custom text trigger called TimerUtils
//* and paste the contents of this script there.
//*
//* To copy from a map to another, copy the trigger holding this
//* library to your map.
//*
//* (requires vJass) More scripts: htt://www.wc3c.net
//*
//* For your timer needs:
//* * Attaching
//* * Recycling (with double-free protection)
//*
//* set t=NewTimer() : Get a timer (alternative to CreateTimer)
//* ReleaseTimer(t) : Relese a timer (alt to DestroyTimer)
//* SetTimerData(t,2) : Attach value 2 to timer
//* GetTimerData(t) : Get the timer's value.
//* You can assume a timer's value is 0
//* after NewTimer.
//*
//* Multi-flavor:
//* Set USE_HASH_TABLE to true if you don't want to complicate your life.
//*
//* If you like speed and giberish try learning about the other flavors.
//*
//********************************************************************
//================================================================
globals
//How to tweak timer utils:
// USE_HASH_TABLE = true (new blue)
// * SAFEST
// * SLOWEST (though hash tables are kind of fast)
//
// USE_HASH_TABLE = false, USE_FLEXIBLE_OFFSET = true (orange)
// * kinda safe (except there is a limit in the number of timers)
// * ALMOST FAST
//
// USE_HASH_TABLE = false, USE_FLEXIBLE_OFFSET = false (red)
// * THE FASTEST (though is only faster than the previous method
// after using the optimizer on the map)
// * THE LEAST SAFE ( you may have to tweak OFSSET manually for it to
// work)
//
private constant boolean USE_HASH_TABLE = true
private constant boolean USE_FLEXIBLE_OFFSET = false
private constant integer OFFSET = 0x100000
private integer VOFFSET = OFFSET
//Timers to preload at map init:
private constant integer QUANTITY = 256
//Changing this to something big will allow you to keep recycling
// timers even when there are already AN INCREDIBLE AMOUNT of timers in
// the stack. But it will make things far slower so that's probably a bad idea...
private constant integer ARRAY_SIZE = 8190
endglobals
//==================================================================================================
globals
private integer array data[ARRAY_SIZE]
private hashtable ht
endglobals
//It is dependent on jasshelper's recent inlining optimization in order to perform correctly.
function SetTimerData takes timer t, integer value returns nothing
static if(USE_HASH_TABLE) then
// new blue
call SaveInteger(ht,0,GetHandleId(t), value)
elseif (USE_FLEXIBLE_OFFSET) then
// orange
static if (DEBUG_MODE) then
if(GetHandleId(t)-VOFFSET<0) then
call BJDebugMsg("SetTimerData: Wrong handle id, only use SetTimerData on timers created by NewTimer")
endif
endif
set data[GetHandleId(t)-VOFFSET]=value
else
// new red
static if (DEBUG_MODE) then
if(GetHandleId(t)-OFFSET<0) then
call BJDebugMsg("SetTimerData: Wrong handle id, only use SetTimerData on timers created by NewTimer")
endif
endif
set data[GetHandleId(t)-OFFSET]=value
endif
endfunction
function GetTimerData takes timer t returns integer
static if(USE_HASH_TABLE) then
// new blue
return LoadInteger(ht,0,GetHandleId(t) )
elseif (USE_FLEXIBLE_OFFSET) then
// orange
static if (DEBUG_MODE) then
if(GetHandleId(t)-VOFFSET<0) then
call BJDebugMsg("SetTimerData: Wrong handle id, only use SetTimerData on timers created by NewTimer")
endif
endif
return data[GetHandleId(t)-VOFFSET]
else
// new red
static if (DEBUG_MODE) then
if(GetHandleId(t)-OFFSET<0) then
call BJDebugMsg("SetTimerData: Wrong handle id, only use SetTimerData on timers created by NewTimer")
endif
endif
return data[GetHandleId(t)-OFFSET]
endif
endfunction
//==========================================================================================
globals
private timer array tT[ARRAY_SIZE]
private integer tN = 0
private constant integer HELD=0x28829022
//use a totally random number here, the more improbable someone uses it, the better.
endglobals
//==========================================================================================
function NewTimer takes nothing returns timer
if (tN==0) then
//If this happens then the QUANTITY rule has already been broken, try to fix the
// issue, else fail.
debug call BJDebugMsg("NewTimer: Warning, Exceeding TimerUtils_QUANTITY, make sure all timers are getting recycled correctly")
static if( not USE_HASH_TABLE) then
debug call BJDebugMsg("In case of errors, please increase it accordingly, or set TimerUtils_USE_HASH_TABLE to true")
set tT[0]=CreateTimer()
static if( USE_FLEXIBLE_OFFSET) then
if (GetHandleId(tT[0])-VOFFSET<0) or (GetHandleId(tT[0])-VOFFSET>=ARRAY_SIZE) then
//all right, couldn't fix it
call BJDebugMsg("NewTimer: Unable to allocate a timer, you should probably set TimerUtils_USE_HASH_TABLE to true or fix timer leaks.")
return null
endif
else
if (GetHandleId(tT[0])-OFFSET<0) or (GetHandleId(tT[0])-OFFSET>=ARRAY_SIZE) then
//all right, couldn't fix it
call BJDebugMsg("NewTimer: Unable to allocate a timer, you should probably set TimerUtils_USE_HASH_TABLE to true or fix timer leaks.")
return null
endif
endif
endif
else
set tN=tN-1
endif
call SetTimerData(tT[tN],0)
return tT[tN]
endfunction
//==========================================================================================
function ReleaseTimer takes timer t returns nothing
if(t==null) then
debug call BJDebugMsg("Warning: attempt to release a null timer")
return
endif
if (tN==ARRAY_SIZE) then
debug call BJDebugMsg("Warning: Timer stack is full, destroying timer!!")
//stack is full, the map already has much more troubles than the chance of bug
call DestroyTimer(t)
else
call PauseTimer(t)
if(GetTimerData(t)==HELD) then
debug call BJDebugMsg("Warning: ReleaseTimer: Double free!")
return
endif
call SetTimerData(t,HELD)
set tT[tN]=t
set tN=tN+1
endif
endfunction
private function init takes nothing returns nothing
local integer i=0
local integer o=-1
local boolean oops = false
static if( USE_HASH_TABLE ) then
set ht = InitHashtable()
loop
exitwhen(i==QUANTITY)
set tT[i]=CreateTimer()
call SetTimerData(tT[i], HELD)
set i=i+1
endloop
set tN = QUANTITY
else
loop
set i=0
loop
exitwhen (i==QUANTITY)
set tT[i] = CreateTimer()
if(i==0) then
set VOFFSET = GetHandleId(tT[i])
static if(USE_FLEXIBLE_OFFSET) then
set o=VOFFSET
else
set o=OFFSET
endif
endif
if (GetHandleId(tT[i])-o>=ARRAY_SIZE) then
exitwhen true
endif
if (GetHandleId(tT[i])-o>=0) then
set i=i+1
endif
endloop
set tN = i
exitwhen(tN == QUANTITY)
set oops = true
exitwhen not USE_FLEXIBLE_OFFSET
debug call BJDebugMsg("TimerUtils_init: Failed a initialization attempt, will try again")
endloop
if(oops) then
static if ( USE_FLEXIBLE_OFFSET) then
debug call BJDebugMsg("The problem has been fixed.")
//If this message doesn't appear then there is so much
//handle id fragmentation that it was impossible to preload
//so many timers and the thread crashed! Therefore this
//debug message is useful.
elseif(DEBUG_MODE) then
call BJDebugMsg("There were problems and the new timer limit is "+I2S(i))
call BJDebugMsg("This is a rare ocurrence, if the timer limit is too low:")
call BJDebugMsg("a) Change USE_FLEXIBLE_OFFSET to true (reduces performance a little)")
call BJDebugMsg("b) or try changing OFFSET to "+I2S(VOFFSET) )
endif
endif
endif
endfunction
endlibrary
//TESH.scrollpos=0
//TESH.alwaysfold=0
library GroupUtils initializer Init requires optional xebasic
//******************************************************************************
//* BY: Rising_Dusk
//*
//* This library is a combination of several features relevant to groups. First
//* and foremost, it contains a group stack that you can access dynamic groups
//* from. It also provides means to refresh groups and clear any shadow
//* references within them. The included boolexprs are there for backwards
//* compatibility with maps that happen to use them. Since the 1.24c patch,
//* null boolexprs used in GroupEnumUnits* calls no longer leak, so there is no
//* performance gain to using the BOOLEXPR_TRUE constant.
//*
//* Instead of creating/destroying groups, we have moved on to recycling them.
//* NewGroup pulls a group from the stack and ReleaseGroup adds it back. Always
//* remember to call ReleaseGroup on a group when you are done using it. If you
//* fail to do so enough times, the stack will overflow and no longer work.
//*
//* GroupRefresh cleans a group of any shadow references which may be clogging
//* its hashtable. If you remove a unit from the game who is a member of a unit
//* group, it will 'effectively' remove the unit from the group, but leave a
//* shadow in its place. Calling GroupRefresh on a group will clean up any
//* shadow references that may exist within it. It is only worth doing this on
//* groups that you plan to have around for awhile.
//*
//* Constants that can be used from the library:
//* [group] ENUM_GROUP As you might expect, this group is good for
//* when you need a group just for enumeration.
//* [boolexpr] BOOLEXPR_TRUE This is a true boolexpr, which is important
//* because a 'null' boolexpr in enumeration
//* calls results in a leak. Use this instead.
//* [boolexpr] BOOLEXPR_FALSE This exists mostly for completeness.
//*
//* This library also includes a simple implementation of a group enumeration
//* call that factors collision of units in a given area of effect. This is
//* particularly useful because GroupEnumUnitsInRange doesn't factor collision.
//*
//* In your map, you can just replace all instances of GroupEnumUnitsInRange
//* with GroupEnumUnitsInArea with identical arguments and your spells will
//* consider all units colliding with the area of effect. After calling this
//* function as you would normally call GroupEnumUnitsInRange, you are free to
//* do anything with the group that you would normally do.
//*
//* If you don't use xebasic in your map, you may edit the MAX_COLLISION_SIZE
//* variable below and the library will use that as the added radius to check.
//* If you use xebasic, however, the script will automatically use xe's
//* collision size variable.
//*
//* You are also able to use GroupUnitsInArea. This function returns all units
//* within the area, no matter what they are, which can be convenient for those
//* instances where you actually want that.
//*
//* Example usage:
//* local group MyGroup = NewGroup()
//* call GroupRefresh(MyGroup)
//* call ReleaseGroup(MyGroup)
//* call GroupEnumUnitsInArea(ENUM_GROUP, x, y, 350., BOOLEXPR_TRUE)
//* call GroupUnitsInArea(ENUM_GROUP, x, y, 350.)
//*
globals
//If you don't have xebasic in your map, this value will be used instead.
//This value corresponds to the max collision size of a unit in your map.
private constant real MAX_COLLISION_SIZE = 197.
//If you are insane and don't care about any of the protection involved in
//this library, but want this script to be really fast, set this to true.
private constant boolean LESS_SAFETY = false
endglobals
globals
//* Constants that are available to the user
group ENUM_GROUP = CreateGroup()
boolexpr BOOLEXPR_TRUE = null
boolexpr BOOLEXPR_FALSE = null
endglobals
globals
//* Hashtable for debug purposes
private hashtable ht = InitHashtable()
//* Temporary references for GroupRefresh
private boolean Flag = false
private group Refr = null
//* Arrays and counter for the group stack
private group array Groups
private integer Count = 0
//* Variables for use with the GroupUnitsInArea function
private real X = 0.
private real Y = 0.
private real R = 0.
private hashtable H = InitHashtable()
endglobals
private function HookDestroyGroup takes group g returns nothing
if g == ENUM_GROUP then
call BJDebugMsg(SCOPE_PREFIX+"Warning: ENUM_GROUP destroyed")
endif
endfunction
debug hook DestroyGroup HookDestroyGroup
private function AddEx takes nothing returns nothing
if Flag then
call GroupClear(Refr)
set Flag = false
endif
call GroupAddUnit(Refr, GetEnumUnit())
endfunction
function GroupRefresh takes group g returns nothing
set Flag = true
set Refr = g
call ForGroup(Refr, function AddEx)
if Flag then
call GroupClear(g)
endif
endfunction
function NewGroup takes nothing returns group
if Count == 0 then
set Groups[0] = CreateGroup()
else
set Count = Count - 1
endif
static if not LESS_SAFETY then
call SaveInteger(ht, 0, GetHandleId(Groups[Count]), 1)
endif
return Groups[Count]
endfunction
function ReleaseGroup takes group g returns boolean
local integer id = GetHandleId(g)
static if LESS_SAFETY then
if g == null then
debug call BJDebugMsg(SCOPE_PREFIX+"Error: Null groups cannot be released")
return false
elseif Count == 8191 then
debug call BJDebugMsg(SCOPE_PREFIX+"Error: Max groups achieved, destroying group")
call DestroyGroup(g)
return false
endif
else
if g == null then
debug call BJDebugMsg(SCOPE_PREFIX+"Error: Null groups cannot be released")
return false
elseif not HaveSavedInteger(ht, 0, id) then
debug call BJDebugMsg(SCOPE_PREFIX+"Error: Group not part of stack")
return false
elseif LoadInteger(ht, 0, id) == 2 then
debug call BJDebugMsg(SCOPE_PREFIX+"Error: Groups cannot be multiply released")
return false
elseif Count == 8191 then
debug call BJDebugMsg(SCOPE_PREFIX+"Error: Max groups achieved, destroying group")
call DestroyGroup(g)
return false
endif
call SaveInteger(ht, 0, id, 2)
endif
call GroupClear(g)
set Groups[Count] = g
set Count = Count + 1
return true
endfunction
private function Filter takes nothing returns boolean
return IsUnitInRangeXY(GetFilterUnit(), X, Y, R)
endfunction
private function HookDestroyBoolExpr takes boolexpr b returns nothing
local integer bid = GetHandleId(b)
if HaveSavedHandle(H, 0, bid) then
//Clear the saved boolexpr
call DestroyBoolExpr(LoadBooleanExprHandle(H, 0, bid))
call RemoveSavedHandle(H, 0, bid)
endif
endfunction
hook DestroyBoolExpr HookDestroyBoolExpr
private constant function GetRadius takes real radius returns real
static if LIBRARY_xebasic then
return radius+XE_MAX_COLLISION_SIZE
else
return radius+MAX_COLLISION_SIZE
endif
endfunction
function GroupEnumUnitsInArea takes group whichGroup, real x, real y, real radius, boolexpr filter returns nothing
local real prevX = X
local real prevY = Y
local real prevR = R
local integer bid = 0
//Set variables to new values
set X = x
set Y = y
set R = radius
if filter == null then
//Adjusts for null boolexprs passed to the function
set filter = Condition(function Filter)
else
//Check for a saved boolexpr
set bid = GetHandleId(filter)
if HaveSavedHandle(H, 0, bid) then
//Set the filter to use to the saved one
set filter = LoadBooleanExprHandle(H, 0, bid)
else
//Create a new And() boolexpr for this filter
set filter = And(Condition(function Filter), filter)
call SaveBooleanExprHandle(H, 0, bid, filter)
endif
endif
//Enumerate, if they want to use the boolexpr, this lets them
call GroupEnumUnitsInRange(whichGroup, x, y, GetRadius(radius), filter)
//Give back original settings so nested enumerations work
set X = prevX
set Y = prevY
set R = prevR
endfunction
function GroupUnitsInArea takes group whichGroup, real x, real y, real radius returns nothing
local real prevX = X
local real prevY = Y
local real prevR = R
//Set variables to new values
set X = x
set Y = y
set R = radius
//Enumerate
call GroupEnumUnitsInRange(whichGroup, x, y, GetRadius(radius), Condition(function Filter))
//Give back original settings so nested enumerations work
set X = prevX
set Y = prevY
set R = prevR
endfunction
private function True takes nothing returns boolean
return true
endfunction
private function False takes nothing returns boolean
return false
endfunction
private function Init takes nothing returns nothing
set BOOLEXPR_TRUE = Condition(function True)
set BOOLEXPR_FALSE = Condition(function False)
endfunction
endlibrary
//TESH.scrollpos=27
//TESH.alwaysfold=0
library xebasic
//**************************************************************************
//
// xebasic 0.4
// =======
// XE_DUMMY_UNITID : Rawcode of the dummy unit in your map. It should
// use the dummy.mdx model, so remember to import it as
// well, just use copy&paste to copy the dummy from the
// xe map to yours, then change the rawcode.
//
// XE_HEIGHT_ENABLER: Medivh's raven form ability, you may need to change
// this rawcode to another spell that morphs into a flier
// in case you modified medivh's spell in your map.
//
// XE_TREE_RECOGNITION: The ancients' Eat tree ability, same as with medivh
// raven form, you might have to change it.
//
// XE_ANIMATION_PERIOD: The global period of animation used by whatever
// timer that depends on it, if you put a low value
// the movement will look good but it may hurt your
// performance, if instead you use a high value it
// will not lag but will be fast.
//
// XE_MAX_COLLISION_SIZE: The maximum unit collision size in your map, if
// you got a unit bigger than 197.0 it would be
// a good idea to update this constant, since some
// enums will not find it. Likewise, if none of
// your units can go bellow X and X is much smaller
// than 197.0, it would be a good idea to update
// as well, since it will improve the performance
// those enums.
//
// Notice you probably don't have to update this library, unless I specify
// there are new constants which would be unlikely.
//
//**************************************************************************
//===========================================================================
globals
constant integer XE_DUMMY_UNITID = 'e000'
constant integer XE_HEIGHT_ENABLER = 'Amrf'
constant integer XE_TREE_RECOGNITION = 'Aeat'
constant real XE_ANIMATION_PERIOD = 0.025
constant real XE_MAX_COLLISION_SIZE = 197.0
endglobals
endlibrary
//TESH.scrollpos=0
//TESH.alwaysfold=0
library xefx initializer init requires xebasic
//**************************************************
// xefx 0.7
// --------
// Recommended: ARGB (adds ARGBrecolor method)
// For your movable fx needs
//
//**************************************************
//==================================================
globals
private constant integer MAX_INSTANCES = 8190 //change accordingly.
private constant real RECYCLE_DELAY = 4.0
//recycling, in order to show the effect correctly, must wait some time before
//removing the unit.
private timer recycler
private timer NOW
endglobals
private struct recyclebin extends array
unit u
real schedule
static recyclebin end=0
static recyclebin begin=0
static method Recycle takes nothing returns nothing
call RemoveUnit(.begin.u) //this unit is private, systems shouldn't mess with it.
set .begin.u=null
set .begin=recyclebin(integer(.begin)+1)
if(.begin==.end) then
set .begin=0
set .end=0
else
call TimerStart(recycler, .begin.schedule-TimerGetElapsed(NOW), false, function recyclebin.Recycle)
endif
endmethod
endstruct
private function init takes nothing returns nothing
set recycler=CreateTimer()
set NOW=CreateTimer()
call TimerStart(NOW,43200,true,null)
endfunction
struct xefx[MAX_INSTANCES]
public integer tag=0
private unit dummy
private effect fx=null
private real zang=0.0
private integer r=255
private integer g=255
private integer b=255
private integer a=255
private integer abil=0
static method create takes real x, real y, real facing returns xefx
local xefx this=xefx.allocate()
set this.dummy= CreateUnit(Player(15), XE_DUMMY_UNITID, x,y, facing*bj_RADTODEG)
call UnitAddAbility(this.dummy,XE_HEIGHT_ENABLER)
call UnitAddAbility(this.dummy,'Aloc')
call UnitRemoveAbility(this.dummy,XE_HEIGHT_ENABLER)
call SetUnitX(this.dummy,x)
call SetUnitY(this.dummy,y)
return this
endmethod
method operator owner takes nothing returns player
return GetOwningPlayer(this.dummy)
endmethod
method operator owner= takes player p returns nothing
call SetUnitOwner(this.dummy,p,false)
endmethod
method operator teamcolor= takes playercolor c returns nothing
call SetUnitColor(this.dummy,c)
endmethod
method operator scale= takes real value returns nothing
call SetUnitScale(this.dummy,value,value,value)
endmethod
//! textmacro XEFX_colorstuff takes colorname, colorvar
method operator $colorname$ takes nothing returns integer
return this.$colorvar$
endmethod
method operator $colorname$= takes integer value returns nothing
set this.$colorvar$=value
call SetUnitVertexColor(this.dummy,this.r,this.g,this.b,this.a)
endmethod
//! endtextmacro
//! runtextmacro XEFX_colorstuff("red","r")
//! runtextmacro XEFX_colorstuff("green","g")
//! runtextmacro XEFX_colorstuff("blue","b")
//! runtextmacro XEFX_colorstuff("alpha","a")
method recolor takes integer r, integer g , integer b, integer a returns nothing
set this.r=r
set this.g=g
set this.b=b
set this.a=a
call SetUnitVertexColor(this.dummy,this.r,this.g,this.b,this.a)
endmethod
implement optional ARGBrecolor
method operator abilityid takes nothing returns integer
return this.abil
endmethod
method operator abilityid= takes integer a returns nothing
if(this.abil!=0) then
call UnitRemoveAbility(this.dummy,this.abil)
endif
if(a!=0) then
call UnitAddAbility(this.dummy,a)
endif
set this.abil=a
endmethod
method operator abilityLevel takes nothing returns integer
return GetUnitAbilityLevel( this.dummy, this.abil)
endmethod
method operator abilityLevel= takes integer newLevel returns nothing
call SetUnitAbilityLevel(this.dummy, this.abil, newLevel)
endmethod
method flash takes string fx returns nothing
call DestroyEffect(AddSpecialEffectTarget(fx,this.dummy,"origin"))
endmethod
method operator xyangle takes nothing returns real
return GetUnitFacing(this.dummy)*bj_DEGTORAD
endmethod
method operator xyangle= takes real value returns nothing
call SetUnitFacing(this.dummy,value*bj_RADTODEG)
endmethod
method operator zangle takes nothing returns real
return this.zang
endmethod
method operator zangle= takes real value returns nothing
local integer i=R2I(value*bj_RADTODEG+90.5)
set this.zang=value
if(i>=180) then
set i=179
elseif(i<0) then
set i=0
endif
call SetUnitAnimationByIndex(this.dummy, i )
endmethod
method operator x takes nothing returns real
return GetUnitX(this.dummy)
endmethod
method operator y takes nothing returns real
return GetUnitY(this.dummy)
endmethod
method operator z takes nothing returns real
return GetUnitFlyHeight(this.dummy)
endmethod
method operator z= takes real value returns nothing
call SetUnitFlyHeight(this.dummy,value,0)
endmethod
method operator x= takes real value returns nothing
call SetUnitX(this.dummy,value)
endmethod
method operator y= takes real value returns nothing
call SetUnitY(this.dummy,value)
endmethod
method operator fxpath= takes string newpath returns nothing
if (this.fx!=null) then
call DestroyEffect(this.fx)
endif
if (newpath=="") then
set this.fx=null
else
set this.fx=AddSpecialEffectTarget(newpath,this.dummy,"origin")
endif
endmethod
method hiddenReset takes string newfxpath, real newfacing returns nothing
local real x = GetUnitX(this.dummy)
local real y = GetUnitY(this.dummy)
local real z = this.z
local real za = this.zangle
local integer level = this.abilityLevel
set fxpath=null
call RemoveUnit(this.dummy)
set this.dummy= CreateUnit(Player(15), XE_DUMMY_UNITID, x,y, newfacing*bj_RADTODEG)
if(level != 0) then
call UnitAddAbility(this.dummy, abilityid)
endif
call UnitAddAbility(this.dummy,XE_HEIGHT_ENABLER)
call UnitAddAbility(this.dummy,'Aloc')
call UnitRemoveAbility(this.dummy,XE_HEIGHT_ENABLER)
call SetUnitX(this.dummy,x)
call SetUnitY(this.dummy,y)
set this.z = z
set zangle = za
endmethod
private method onDestroy takes nothing returns nothing
if(this.abil!=0) then
call UnitRemoveAbility(this.dummy,this.abil)
endif
if(this.fx!=null) then
call DestroyEffect(this.fx)
set this.fx=null
endif
if (recyclebin.end==MAX_INSTANCES) then
//I'd like to see this happen...
call TimerStart(recycler,0,false,function recyclebin.Recycle)
call ExplodeUnitBJ(this.dummy)
else
set recyclebin.end.u=this.dummy
set recyclebin.end.schedule=TimerGetElapsed(NOW)+RECYCLE_DELAY
set recyclebin.end= recyclebin( integer(recyclebin.end)+1)
if( recyclebin.end==1) then
call TimerStart(recycler, RECYCLE_DELAY, false, function recyclebin.Recycle)
endif
call SetUnitOwner(this.dummy,Player(15),false)
endif
set this.dummy=null
endmethod
method hiddenDestroy takes nothing returns nothing
call ShowUnit(dummy,false)
call destroy()
endmethod
endstruct
endlibrary
//TESH.scrollpos=131
//TESH.alwaysfold=0
//====================================
//Malice Orb v1.01 by watermelon_1234
//====================================
//Required Libraries: TimerUtils, GroupUtils, and xe system (xebasic & xefx)
//====================================
//Copy Object Editor Data:
//-Malice Orb ability
//====================================
scope MaliceOrb
native UnitAlive takes unit id returns boolean //Remove this line if it's already implemented
//*********************************
//Settings
//*********************************
globals
private constant integer SPELL_ID = 'A000' //The raw id of the Malice Orb ability
private constant string SPELL_ORDER = "darkritual" //The order string of the Malice Orb ability. Must be the Base Order Id, not Order String!
private constant real TIMER_LOOP = 0.1 //How many times the timer will loop. High values aren't recommended for this spell
private constant string ORB_SFX = "Abilities\\Spells\\Undead\\AntiMagicShell\\AntiMagicShell.mdl" //The SFX for the orb
private constant real ORB_HEIGHT = 200. //What height the orb should be at upon creation
private constant string BURST_SFX = "Objects\\Spawnmodels\\Undead\\UDeathSmall\\UDeathSmall.mdl" //The explosion SFX when the spell stops
private constant real BURST_HEIGHT = 150. //Height of the burst sfx
private constant string GROW_SFX = "Abilities\\Spells\\Undead\\Possession\\PossessionMissile.mdl" //A little SFX shown periodically to show the orb is growing
private constant real GROW_HEIGHT = 150. //Height of the grow sfx
private constant real GROW_SFX_INT = 1.5 //The interval when the GROWSFX will be played
private constant attacktype ATK_TYPE = ATTACK_TYPE_NORMAL //Attack type of the damage
private constant damagetype DMG_TYPE = DAMAGE_TYPE_UNIVERSAL //Damage type of the damage
private constant weapontype WPN_TYPE = null //Weapon type of the damage
private constant boolean DO_PRELOADING = true //Determine whether or not to preload the ghost unit and the special effects.
endglobals
//The Channel duration of the spell. Make sure it matches the duration put in the spell.
private function ChannelDuration takes integer lvl returns real
return 6.
endfunction
//The initial size of the orb.
private function InitScale takes integer lvl returns real
return 0.5+0.5*lvl
endfunction
//How much the orb should increase in size per second.
private function ScaleIncrement takes integer lvl returns real
return .1
endfunction
private function InitArea takes integer lvl returns real
//The initial area of the spell
return 100.+50*lvl
endfunction
private function AreaIncrement takes integer lvl returns real
//How much the area will increase per second.
return 5.
endfunction
private function InitDamage takes integer lvl returns real
//The amount of damage done without any consideration of DamageIncrement
return 75. + 25*lvl
endfunction
private function DamageIncrement takes integer lvl returns real
//How much the damage should increase by every second
return 5. + 10*lvl
endfunction
//Settings for the texttag that will display the total amount of damage dealt
private function MakeTextTag takes unit cast,real dmg returns nothing
set bj_lastCreatedTextTag = CreateTextTag() //Used a global variable since I'm lazy. :P
call SetTextTagPosUnit(bj_lastCreatedTextTag,cast,-15)
call SetTextTagText(bj_lastCreatedTextTag,"-"+I2S(R2I(dmg))+"!",0.0312)
call SetTextTagColor(bj_lastCreatedTextTag,0,255,0,255)
call SetTextTagVelocity(bj_lastCreatedTextTag,0,0.04)
call SetTextTagFadepoint(bj_lastCreatedTextTag,0.65)
call SetTextTagLifespan(bj_lastCreatedTextTag,1)
call SetTextTagPermanent(bj_lastCreatedTextTag,false)
endfunction
//***************************************************************************************************
//Actual coding of the spell below here
//***************************************************************************************************
globals
private boolexpr e
endglobals
private struct Data
unit cast
xefx orb
integer lvl
real count = 0 //This variable counts how long the spell has been channeled
real growCount = 0 //A separate variable is needed to know when to play the GROWSFX
real dmg
real totalDmg = 0
timer t
private static thistype temp
static method create takes unit c, real x, real y returns thistype
local thistype this = thistype.allocate()
set .cast = c
set .lvl = GetUnitAbilityLevel(.cast,SPELL_ID)
set .orb = xefx.create(x,y,0)
set .orb.z = ORB_HEIGHT
set .orb.fxpath = ORB_SFX
set .orb.scale = InitScale(.lvl)
set .t = NewTimer()
call SetTimerData(.t,this)
call TimerStart(.t,TIMER_LOOP,true,function thistype.onLoop)
return this
endmethod
//Chooses the targets that will be affected and deals damage. Also adds the damage done
static method filter takes nothing returns boolean
local unit u = GetFilterUnit()
local real life = GetWidgetLife(u)
if UnitAlive(u) and not IsUnitType(u,UNIT_TYPE_MAGIC_IMMUNE) and IsUnitEnemy(u,GetOwningPlayer(temp.cast)) then
call UnitDamageTarget(temp.cast,u,temp.dmg,false,true,ATK_TYPE,DMG_TYPE,WPN_TYPE)
set temp.totalDmg = temp.totalDmg + life - GetWidgetLife(u)
endif
set u = null
return false
endmethod
static method onLoop takes nothing returns nothing
local thistype this = GetTimerData(GetExpiredTimer())
local xefx sfx //Plays an sfx where the orb is. Has the same height as the orb.
if GetUnitCurrentOrder(.cast) == OrderId(SPELL_ORDER) and .count <= ChannelDuration(.lvl) then
set .count = .count + TIMER_LOOP
set .growCount = .growCount + TIMER_LOOP
set .orb.scale = InitScale(.lvl) +ScaleIncrement(.lvl)*.count
if .growCount >= GROW_SFX_INT then //If the growCount is at least the GROW_SFX_INT, create a nice effect for the orb
set sfx = xefx.create(.orb.x,.orb.y,0)
set sfx.fxpath = GROW_SFX
set sfx.z = GROW_HEIGHT
set sfx.scale = InitScale(.lvl) +ScaleIncrement(.lvl)*.count
call sfx.destroy()
set .growCount = 0 //set it back to 0 to restart counting
endif
else
if .count > ChannelDuration(.lvl) then //This is just to prevent the spell from damaging higher than it should
set .count = ChannelDuration(.lvl)
endif
set sfx = xefx.create(.orb.x,.orb.y,0)
set sfx.fxpath = BURST_SFX
set sfx.z = BURST_HEIGHT
set sfx.scale = InitScale(.lvl) +ScaleIncrement(.lvl)*.count
call sfx.destroy()
set .dmg = InitDamage(.lvl)+DamageIncrement(.lvl)*.count
set temp = this
call GroupEnumUnitsInArea(ENUM_GROUP,.orb.x,.orb.y,InitArea(.lvl) + AreaIncrement(.lvl)*.count,e)
if .totalDmg > 0 then //This deals with the creation of a texttag that displays the total damage done if greater than 0.
call MakeTextTag(.cast,.totalDmg)
endif
call ReleaseTimer(.t)
call .orb.destroy() //Destroy the orb effect.
call .destroy()
endif
endmethod
static method spellActions takes nothing returns boolean
if GetSpellAbilityId() == SPELL_ID then
call thistype.create(GetTriggerUnit(),GetSpellTargetX(),GetSpellTargetY())
endif
return false
endmethod
static method onInit takes nothing returns nothing
local trigger t = CreateTrigger()
call TriggerRegisterAnyUnitEventBJ(t,EVENT_PLAYER_UNIT_SPELL_EFFECT)
call TriggerAddCondition(t,Condition(function thistype.spellActions))
static if DO_PRELOADING then
call Preload(ORB_SFX)
call Preload(BURST_SFX)
call Preload(GROW_SFX)
endif
set e = Filter(function thistype.filter)
endmethod
endstruct
endscope
//TESH.scrollpos=12
//TESH.alwaysfold=0
//====================================
//Torment v1.01 by watermelon_1234
//====================================
//Required Libraries: TimerUtils
//====================================
//Copy Object Editor Data:
//*Torment ability
//*Torment buff
//*Torment unit
//====================================
scope Torment
native UnitAlive takes unit id returns boolean //Remove this line if it's already implemented
//*********************************
//Settings
//*********************************
globals
private constant integer SPELL_ID = 'A001' //The raw ID for the Torment spell
private constant integer BUFF_ID = 'B000' //The raw ID for the Torment buff
private constant integer GHOST_ID = 'h000' //The raw ID of the Torment (Dummy) unit that will follow the target
private constant string BIRTH_SFX = "Abilities\\Spells\\Undead\\AnimateDead\\AnimateDeadTarget.mdl" //Plays an SFX where the ghost will spawn
private constant string DAMAGE_SFX = "Abilities\\Spells\\Undead\\DeathandDecay\\DeathandDecayDamage.mdl" //The effect that will play when the spell damages the target.
private constant string DAMAGE_SFX_ATTACH = "head" //The attachment point for the DAMAGESFX
private constant string KILL_SFX = "Objects\\Spawnmodels\\Undead\\UndeadDissipate\\UndeadDissipate.mdl" //The effect that plays when damage dealt from this spell causes the target to die.
private constant real BIRTH_OFFSET = 75. //How far away the BIRTH_SFX should be played from the caster
private constant real TIMER_LOOP = 0.25 //This refers to how many times the timer will run the function.
private constant attacktype ATK_TYPE = ATTACK_TYPE_NORMAL //Attack type of the damage
private constant damagetype DMG_TYPE = DAMAGE_TYPE_UNIVERSAL //Damage type of the damage
private constant weapontype WPN_TYPE = null //Weapon type of the damage
private constant boolean DO_PRELOADING = true //Determine whether or not to preload the ghost unit and the special effects.
endglobals
//This function sets up how the ghost will look like and more importantly, its movement speed.
private function GhostSetUp takes unit ghost, integer lvl returns nothing
call SetUnitVertexColor(ghost,255,255,255,100)
call SetUnitMoveSpeed(ghost,165.+15*lvl)
endfunction
//Max damage dealt to the target per second when the ghost is within MaxDamageDistance
private constant function Damage takes integer lvl returns real
return 25.+10*lvl
endfunction
//Duration of the buff.
private constant function Duration takes integer lvl returns real
return 4.+1*lvl
endfunction
//The distance between the ghost and target unit when full damage will be dealt
private constant function MaxDamageDistance takes integer lvl returns real
return 75.+25*lvl
endfunction
//The formula to calculate the damage with distance in mind
private constant function DamageDistanceFormula takes integer lvl, real dist returns real
if dist <= MaxDamageDistance(lvl) then
return Damage(lvl)
endif
return Damage(lvl)*MaxDamageDistance(lvl)/dist
endfunction
//***************************************************************************************************
//Actual coding of the spell below here. Don't touch unless you know what you're doing!
//***************************************************************************************************
private struct Data
unit caster
unit target
unit ghost = null //This unit will be created inside the struct. Null at first to show that it's not created yet.
integer level
boolean buffed = false //The boolean will be used to detect when the target will receive the buff
real count = 0 //count will be used to prevent stacking
//The following two variables will be used to check if the target has changed it location
real targetx
real targety
timer t //Timer used for looping...
static method create takes unit c, unit targ returns thistype
local thistype this = thistype.allocate()
local real cx = GetUnitX(c)
local real cy = GetUnitY(c)
local real angle = Atan2(GetUnitY(targ)- cy, GetUnitX(targ)- cx)
set .caster = c
set .target = targ
set .level = GetUnitAbilityLevel(c,SPELL_ID)
set .t = NewTimer()
call SetTimerData(.t, this)
call TimerStart(.t,TIMER_LOOP,true,function thistype.onLoop)
call DestroyEffect(AddSpecialEffect(BIRTH_SFX,cx + BIRTH_OFFSET * Cos(angle),cy + BIRTH_OFFSET * Sin(angle)))
return this
endmethod
static method onLoop takes nothing returns nothing
local thistype this = GetTimerData(GetExpiredTimer())
local real x = GetUnitX(.target)
local real y = GetUnitY(.target)
local real dist //Only made a variable for this because it made the UnitDamageTarget line too long
if GetUnitAbilityLevel(.target,BUFF_ID) > 0 and not .buffed then
set .buffed = true
endif
if GetUnitAbilityLevel(.target,BUFF_ID) > 0 and .buffed then
if .ghost == null then //If it hasn't been created yet, create it.
set .ghost = CreateUnit(Player(15),GHOST_ID,x,y,0)
call GhostSetUp(.ghost,.level)
endif
//Checks if the target's x or y coordinate has changed. If so, move to its new coordinates.
if .targetx != x or .targety != y then
call IssuePointOrder(.ghost,"move",x,y)
set .targetx = x
set .targety = y
endif
call DestroyEffect(AddSpecialEffectTarget(DAMAGE_SFX,.target,DAMAGE_SFX_ATTACH))
set dist = SquareRoot((GetUnitX(.ghost)-x)*(GetUnitX(.ghost)-x)+(GetUnitY(.ghost)-y)*(GetUnitY(.ghost)-y))
call UnitDamageTarget(.caster,.target,DamageDistanceFormula(.level,dist)*TIMER_LOOP,false,true,ATK_TYPE,DMG_TYPE,WPN_TYPE)
//Play an SFX if it succeeded in killing it
if not UnitAlive(.target) then
call DestroyEffect(AddSpecialEffect(KILL_SFX,x,y))
else
set .count = .count + TIMER_LOOP //We need to increase .count if the target is still alive.
endif
endif
if .buffed and (GetUnitAbilityLevel(.target, BUFF_ID) < 1 or .count >= Duration(.level)) then
call KillUnit(.ghost)
call ReleaseTimer(.t)
call .destroy()
endif
endmethod
static method spellActions takes nothing returns boolean
if GetSpellAbilityId() == SPELL_ID then
call thistype.create(GetTriggerUnit(),GetSpellTargetUnit())
endif
return false //Never need to run any trigger actions
endmethod
static method onInit takes nothing returns nothing
local trigger t = CreateTrigger()
call TriggerRegisterAnyUnitEventBJ(t,EVENT_PLAYER_UNIT_SPELL_EFFECT)
call TriggerAddCondition( t, Condition( function thistype.spellActions)) //Trigger conditions are faster than trigger actions
//Preloading to remove lag
static if DO_PRELOADING then
call RemoveUnit(CreateUnit(Player(15),GHOST_ID,0,0,0))
call Preload(BIRTH_SFX)
call Preload(KILL_SFX)
call Preload(DAMAGE_SFX)
endif
endmethod
endstruct
endscope