I am going to try and make this a simple example so it does not end up taking me forever
Spell 1 - Lets call it "Stacking Long Term Damage"
You cast a spell, with a short cd, deals DoT to the target, however, a new cast by you restarts this duration, but stacks the damage. So say, cast 1, 25 DoT for 5s, you cast again after 3s, in which 15 damage should have been done, the time resets, but now you are doing 50 DoT for the next 5s, and so on. Now say hero 2 comes up, and wants his own instance of the spell. So he casts the ability on the same poor little target, in the same fashion. The target is now taking 100 DoT, at different intervals, from two seperate casters, which end at seperate times. Now this spell can be used by any number of units on this map.
The way I would have approached this in the past, or rather, in the present, is with a GC approach(the only time I use GC mind you), in a fashion as shown below.
JASS:
struct data
unit caster
unit target
timer t
integer ticks = 5
real damage = 5.
string storage
endstruct
function Effects takes nothing returns nothing
local data d = GetData(GetExpiredTimer())
if d.ticks==0 then
call ClearTable(d.storage)
call EndTimer(d.t)
call d.destroy()
else
set d.ticks = d.ticks - 1
endif
endfunction
function OnCast takes nothing returns nothing
local string s = I2S(H2I(GetTriggerUnit()))+I2S(H2I(GetSpellTargetUnit()))+"Spell Name"
local data d = GetInteger(s,"struct")
if d==0 then
set d = data.create()
set d.caster = GetTriggerUnit()
set d.target = GetSpellTargetUnit()
set d.t = NewTimer()
set d.s = s
call SetData(d.t,d)
call TimerStart(d.t,1.,true,function Effects)
else
call PauseTimer(d.t)
set d.ticks = 5
set d.damage = d.damage + 5.
call TimerStart(d.t,1.,true,function Effects)
endif
endfunction
can anyone think of how to do this w/o using GC?
remember all instances of this spell are independant, damage cannot be grouped unless you can discern who is to deal it, and all intervals/end times should be independant of one another
the only thing i could think of would be to have a timer per unit(or 1 timer, with an array of active instances)(
this again would not allow for independant intervals), with an array of damages, ticks and casters(with an index to keep track of how many there are), where you store who deals what damage when the callback function is ran and how many ticks are left. On a new cast, loop through your index, if the caster is already there, update the damage, time and length, if not, add him in. I can't really say I like this method, I can't see it being any faster then the limited GC here(though maybe it is), and again, the intervals are not independant of one another, which is not desireable
