library respawn initializer init requires respawnunit, respawntype
globals
//config: (some setup constants)
public constant real DEFAULT_FACING = 0.00
public constant player RESPAWN_PLAYER = Player(12) //neutral hostile?
//some other stuff:
private Table reftable
endglobals
//**********************************************************************************************
//* respawn
//*
//*
struct respawn
respawnunit runit //this is automatically deallocated
respawntype rtype
real x
real y
real cooldown = 0.00
boolean pending = false
static method create takes real x, real y, respawntype rtype returns thistype
local thistype r = allocate()
set r.rtype = rtype
set r.x = x
set r.y = y //when a respawn is created there is no associated unit unless
return (r) //one is provided or "spawn" is called.
endmethod
method toString takes nothing returns string
return GetUnitName(runit.me) + ", an ID of " + /*
*/ I2S(rtype.id) + " and category " + rtype.rcat.toString()
endmethod
//spawn: respawns a unit-type at special coordinates if the type is active.
method spawn takes player for returns nothing
local unit u
if (rtype.active) then
set u = CreateUnit(for, rtype.id, x, y, DEFAULT_FACING)
call reftable.remove(runit)
set runit = respawnunit[u] //get the object for the unit
set reftable[runit] = this
set u = null
endif
endmethod
//setunit: sets the spawn-unit in-case it already exists.
method setunit takes unit u returns nothing
local respawnunit conv = respawnunit[u]
if (conv != 0) then
call reftable.remove(runit)
set runit = conv
set reftable[conv] = this
endif
endmethod
//lookup: tries to look the specified respawn-unit up in the reftable.
// --returns a pointer to the respawn that this unit belongs to.
static method lookup takes respawnunit ru returns thistype
if (reftable.has(ru)) then
return (reftable[ru])
endif
return (0)
endmethod
endstruct
//**********************************************************************************************
//* initialization
//*
//*
public function init takes nothing returns nothing
set reftable = Table.create()
endfunction
endlibrarylibrary respawngroup requires respawn, respawntimer, List
//**********************************************************************************
//* respawngroup code:
//*
//*
struct respawngroup
//==============================================================
// Members:
// ----
list members //the list of respawns in group
static Table reftable //unique referencing
static constant real PROXIMITY = 200.00
static constant real PROXIMITY_SQ = 40000.00 //200^2
respawntimer array rtimer [respawncategory.CATEGORIES]
//==============================================================
// Constructor/Destructor:
// ----
static method create takes nothing returns thistype
local thistype rg = allocate()
local integer i = 0
loop
exitwhen (i == respawncategory.CATEGORIES)
set rg.rtimer[i] = respawntimer.create(rg, respawncategory[i])
set i = i + 1
endloop //create the timers pointing to this group
set rg.members = list.create()
return (rg)
endmethod
method onDestroy takes nothing returns nothing
call members.destroy()
endmethod
//toString: returns string representation of object.
method toString takes nothing returns string
local respawn elem
local string result = ""
local integer it = 0
call members.iteratef()
loop
set elem = members.iterate()
set it = it + 1
exitwhen (elem == -1)
set result = result + "[" + I2S(elem) + "]" + elem.toString() + "\n"
endloop
return (result)
endmethod
//add: adds a respawn to the group at the front of list.
method add takes respawn r returns nothing
call members.insertf(r)
set reftable[r] = this
endmethod
//==============================================================
// Utility:
// ----
method check takes respawn r returns boolean
local respawn elem
call members.iteratef()
loop
set elem = members.iterate()
exitwhen (elem == -1)
if (((elem.x-r.x)*(elem.x-r.y)+(elem.y-r.y)*(elem.y-r.y)) < PROXIMITY_SQ) then
return (true)
endif
endloop
return (false)
endmethod
method findCategory takes respawn r returns list
local respawn elem
local list ret = list.create()
call members.iteratef()
loop
set elem = members.iterate()
exitwhen (elem == -1)
if (elem.rtype.rcat == r.rtype.rcat) then
call ret.insertf(elem) //insert element to return list
endif
endloop
return (ret) //return the generated list
endmethod
static method findGroup takes respawn r returns thistype
if (reftable.has(r)) then
return (reftable[r])
endif
return (0) //cannot be found
endmethod
static method operator [] takes respawn r returns thistype
return (reftable[r])
endmethod //this is faster and inline friendly for final draft
//==============================================================
// Initialization:
// ----
static method onInit takes nothing returns nothing
set reftable = Table.create()
endmethod
endstruct
endlibrarylibrary respawntimer
struct respawntimer
respawncategory rcat
respawngroup rgroup
timer tmr
boolean active
static method create takes respawngroup grp, respawncategory category returns thistype
local thistype rt = allocate()
set rt.rcat = category
set rt.rgroup = grp
set rt.tmr = NewTimer()
call SetTimerData(rt.tmr, rt)
set rt.active = false
return (rt)
endmethod
endstruct
endlibrarylibrary respawnunit
//indexed object reference to a unit with some data members for
//respawning specific types of units.
struct respawnunit
implement AutoCreate
implement AutoDestroy
//only create for units that match one of the types as a "respawn"
static method createFilter takes unit u returns boolean
return (respawntype.find(GetUnitTypeId(u)) != 0)
endmethod
endstruct
endlibrarylibrary respawntype requires respawncategory
struct respawntype extends array
//respawntype data:
respawncategory rcat
integer id
boolean active
static integer objc = 0
static Table reftable
//find: finds a "respawntype" associated with a specified ID.
static method find takes integer id returns thistype
if (reftable.has(id)) then
return (reftable[id])
endif
return (0) //not found
endmethod
//new: adds a new type to the stack array with specified values.
static method new takes integer id, respawncategory rcat returns nothing
set thistype[objc].active = true
set thistype[objc].id = id
set thistype[objc].rcat = rcat
set reftable[id] = objc
set objc = objc + 1
endmethod
//initialize our types: (only debug ones for now)
static method onInit takes nothing returns nothing
set reftable = Table.create()
//initialize some types:
call new('hfoo', respawncategory.SEC15)
call new('hpea', respawncategory.SEC10)
call new('nftr', respawncategory.SEC10)
endmethod
endstruct
endlibrarylibrary respawncategory
struct respawncategory extends array
static constant integer SEC10 = 0
static constant integer SEC15 = 1
static constant integer SEC30 = 2
static constant integer SEC45 = 3
static constant integer CATEGORIES = 4
real timeout
//represent a CATEGORY as a string based on the timeout.
method toString takes nothing returns string
return "CATEGORY[" + I2S(R2I(timeout)) + "]"
endmethod
//initialize our respawn categories:
static method onInit takes nothing returns nothing
set thistype[SEC10].timeout = 10.0
set thistype[SEC15].timeout = 15.0
set thistype[SEC30].timeout = 30.0
set thistype[SEC45].timeout = 45.0
endmethod
endstruct
endlibrarylibrary respawnsys initializer init requires respawn
globals
//system dependent variables:
private respawngroup array sysGroup
private integer sysGroupCount = 0
endglobals
//**********************************************************************************************
//* utility
//*
//*
//newGroup:
// --creates a new group and adds the specified respawn to it
private function newGroup takes nothing returns respawngroup
set sysGroup[sysGroupCount] = respawngroup.create()
set sysGroupCount = sysGroupCount + 1
return (sysGroup[sysGroupCount - 1])
endfunction
// checkGroups:
// --checks to see if a respawn 'r' is within the boundaries of
// a previously created group. if so we can add to that group.
// --returns the array index in "sysGroup" of the group.
private function checkGroups takes respawn r returns integer
local integer i = 0
loop
exitwhen (i == sysGroupCount)
if (sysGroup[i].check(r)) then
return (i)
endif //return the index of group
set i = i + 1
endloop
return (-1) //no nearby groups
endfunction
//**********************************************************************************************
//* main
//*
//*
private function onRespawn takes nothing returns nothing
local respawntimer exp = respawntimer(GetTimerData(GetExpiredTimer()))
local respawngroup grp
local respawncategory cat
local respawn elem
if (exp == 0) then
debug call BJDebugMsg("Non-respawn-unit has died. No action.")
return
endif //return if the dying unit is not a respawn
set grp = exp.rgroup
set cat = exp.rcat
call grp.members.iteratef()
loop
set elem = grp.members.iterate()
exitwhen (elem == -1)
//iterate group and spawn units if pending and same category.
if ((elem.pending) and (elem.rtype.rcat == cat)) then
call elem.spawn(respawn_RESPAWN_PLAYER)
endif
endloop
endfunction
private function onDeath takes nothing returns boolean
local respawnunit u = respawnunit[GetTriggerUnit()]
local respawn r
local respawngroup grp
local respawntimer rtmr
local respawn elem
if (u != 0) then //only check respawn-able units
set r = respawn.lookup(u)
set grp = respawngroup.findGroup(r)
//the timer we are operating with:
set rtmr = grp.rtimer[r.rtype.rcat]
//start the timer (ignore previous arrangements for respawns)
call TimerStart(rtmr.tmr, r.rtype.rcat.timeout, false, function onRespawn)
set r.pending = true
endif
return (false)
endfunction
//**********************************************************************************************
//* initialization
//*
//*
public function init takes nothing returns nothing
local group all = CreateGroup()
local unit first
local trigger t = CreateTrigger()
local respawn r
local respawntype rtyp
local respawngroup rgrp
local integer i = 0
call GroupEnumUnitsOfPlayer(all, respawn_RESPAWN_PLAYER, null)
loop
set first = FirstOfGroup(all)
exitwhen (first == null)
set rtyp = respawntype.find(GetUnitTypeId(first))
if (rtyp != 0) then
set r = respawn.create(GetUnitX(first), GetUnitY(first), rtyp)
call r.setunit(first)
set rgrp = sysGroup[checkGroups(r)] //check for any eligable groups.
if (rgrp == 0) then
set rgrp = newGroup()
endif //get new group off stack array
call rgrp.add(r)
endif //add respawn to group found/created
call GroupRemoveUnit(all, first)
endloop
call DestroyGroup(all)
set all = null
set first = null
//register trigger/actions:
call TriggerRegisterAnyUnitEventBJ(t, EVENT_PLAYER_UNIT_DEATH)
call TriggerAddCondition(t, Filter(function onDeath))
endfunction
endlibrary'hpea', 'hfoo' and 'nftr' are already added (to give you an idea of how to add types).
Code said:
respawnunit types. These are only created by the system though, when a unit is spawned (or an initial unit is set), so recycling the IDs is just done right before a new instance is created. This means there should only ever be a static amount of these objects on a map.
Ok, i think its a problem with adding incorrect unit ids. It turns out that the units just weren't respawning, they werent respwaning once and than not anymore. I deleted all unit types except one and thhey respawned fine.
So, basically, adding an invalid id will crash the entire system?
CreateUnit when it is passed invalid parameters.'hfo0' and expect the system to know you want 'hfoo' that would be very silly.'hfoo' raw-code with 'hfo0' and it worked as expected, not respawning any of the Footman but it still respawned the other types of units who's IDs were given valid.
