value = (value === undefined ? def : value);
meta.obj[meta.key] = value;
- this._fireMutation('set', key, old, value, meta.obj);
+ this._emitMutation('set', key, old, value, meta.obj);
}
return this;
},
if ( meta.obj ) {
delete meta.obj[meta.key];
- this._fireMutation('remove', key, old, undefined, meta.obj);
+ this._emitMutation('remove', key, old, undefined, meta.obj);
}
}
return this;
/**
* @private
*/
- _fireMutation : function _fireMutation(evt, key, oldval, newval, obj){
+ _emitMutation : function _emitMutation(evt, key, oldval, newval, obj){
if (newval !== oldval){
var data = {
'key' : key,
'obj' : obj,
'root' : this
};
- this.fire(evt+':'+key, this, data);
- this.fire(evt, this, data);
+ this.emit(evt+':'+key, this, data);
+ this.emit(evt, this, data);
}
return this;
},
key = 'set:'+key;
return key;
}, this);
- this.addEventListener(events, function(evt){
+ this.on(events, function(evt){
obj[evt.data.key.split('.').pop()] = evt.data.newval;
});
return this;
-var Y = require('Y').Y;
-Y['event'] = exports;
+var Y = require('Y').Y
+,
/**
* A simple event.
* TODO: Detect jQuery event objects.
* TODO: If DOM event, wrap with consistent API (use jQuery if present).
*/
-var Event =
+Event =
exports['Event'] =
Y.YObject.subclass('Event', {
+ _stopped : false, // whether propagation is stopped
+
+ type : 'event', // event type
+ target : null, // target of the emitter
+ trigger : null, // object which caused this event
+ data : null, // event data
+
+
+
init : function init( type, target, trigger, data ){
data = data || {};
for (var k in data) this[k] = data[k];
this.trigger = trigger || target;
},
+ /**
+ * @see http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/events.html#Events-Event-stopPropagation
+ */
+ stopPropagation : function stopPropagation(){
+ this._stopped = true;
+ return this;
+ },
+
+ /**
+ * @see http://www.w3.org/TR/2003/WD-DOM-Level-3-Events-20030331/events.html#Events-Event-isPropagationStopped
+ */
+ isPropagationStopped : function isPropagationStopped(){
+ return this._stopped;
+ },
+
toString: function(){ return "Event("+this.type+")"; }
})
* A simple multicaster.
*/
, methods = {
- getQueue : function getQueue(evt){
- var Qs = this.queues;
- if ( !Qs[evt] )
- Qs[evt] = Y([]);
- return Qs[evt];
+
+ listeners : function listeners(evt){
+ return this.queues[evt] ? this.queues[evt].clone() : new Y.YArray();
},
- addEventListener : function addEventListener(evts, fn){
+ willTrigger : function willTrigger(evt){
+ var queue = this.queues[evt];
+ return !!( (queue && queue.length) || (this.parent && this.parent.willTrigger(evt)) );
+ },
+
+ hasListener : function hasListener(evt){
+ var queue = this.queues[evt];
+ return !!(queue && queue.length);
+ },
+
+ addListener : function addListener(evts, fn){
fn = fn.toFunction();
if ( !Y.isArray(evts) )
evts = evts.split(/\s+/);
- evts.forEach(function addEvent(evt){
- this.getQueue(evt).push(fn);
- }, this);
+
+ var queues = this.queues
+ , i=0, L=evts.length, evt=evts[i];
+ for (; i<L; evt=evts[++i])
+ (queues[evt] || (queues[evt] = new Y.YArray()))
+ .push(fn);
+
return this.target;
},
- removeEventListener : function removeEventListener(evt, fn){
- this.getQueue(evt).remove(fn.toFunction());
+ removeListener : function removeListener(evts, fn){
+ fn = fn.toFunction();
+ if ( !Y.isArray(evts) )
+ evts = evts.split(/\s+/);
+
+ var queues = this.queues
+ , i=0, L=evts.length, evt=evts[i];
+ for (; i<L; evt=evts[++i])
+ if ( queues[evt] ) queues[evt].remove(fn);
+
+ return this.target;
},
- fire : function fire(evtname, trigger, data, async){
- var evt = new Event(evtname, this.target, trigger, data);
- if (async)
- setTimeout(this.dispatchEvent.bind(this, evt), 10);
- else
- this.dispatchEvent(evt);
+ removeAllListeners : function removeAllListeners(evts){
+ if ( !Y.isArray(evts) )
+ evts = evts.split(/\s+/);
+
+ for ( var i=0, L=evts.length, evt=evts[i]; i<L; evt=evts[++i] )
+ delete this.queues[evt];
+
+ return this;
+ },
+
+ once : function once(evts, fn){
+ fn = fn.toFunction();
+ var self = this;
+ return self.addListener(evts,
+ function onceHandler(){
+ self.removeListener(evts, arguments.callee);
+ fn.apply(this, arguments);
+ });
+ },
+
+ emit : function emit(evtname, trigger, data){
+ var q = this.queues[evtname]
+ , L = q ? q.length : 0
+ ;
+ if ( !L )
+ return this;
+
+ q = q._o.slice(0);
+ var A = arguments
+ , target = this.target
+ , evt = new Event(evtname, target, trigger, data)
+ , method = (A.length > 3 ? 'apply' : 'call')
+ , args = (A.length > 3 ? [evt].concat(Y(A,3)) : evt)
+ ;
+ for (var i=0, fn=q[i]; i<L; fn=q[++i])
+ fn[method](target, args);
+
+ if (this.parent && !evt._stopped)
+ this.parent.emit.apply(this.parent, A);
+
+ return evt;
+ },
+
+ emitAsync : function emitAsync(evtname, trigger, data){
+ setTimeout(this.emit.bind.apply(this.emit, [this].concat(Y(arguments))), 10);
return evt;
},
* XXX: does not handle degenerate or recursive event dispatch
*/
dispatchEvent : function dispatchEvent(evt){
- this.getQueue(evt.type).invoke('call', evt.target, evt);
- if (this.parent) this.parent.fire(evt.type, evt.trigger, evt.data);
+ var queue = this.queues[evt.type];
+ if (queue && queue.length)
+ queue.invoke('call', evt.target, evt);
+ if (this.parent)
+ this.parent.emit(evt.type, evt.trigger, evt.data);
return evt;
},
* Decorates object with bound methods to act as a delegate of this hub.
*/
decorate : function decorate(delegate){
- if (!delegate) return;
+ if (!delegate)
+ return delegate;
for (var k in methods)
delegate[k] = methods[k].bind(this);
return delegate;
}
-},
+}
+,
Emitter =
exports['Emitter'] =
}
}, methods) )
;
+methods.on = methods.addListener;
Emitter.methods = methods;
// Global Event Hub
Emitter.global = new Emitter()
Emitter.global.decorate(exports);
+
+Y['event'] = exports;
if (val !== this.val) {
this.old = this.val;
this.val = val;
- this.fire('change', this, {
+ this.emit('change', this, {
'key' : this.id,
'oldval' : this.old,
'newval' : this.val,
var field = new Field(chain, def, value);
fields[chain] = field;
group.append(field.el);
- config.addEventListener('set:'+chain, function onConfigSet(evt){
+ config.on('set:'+chain, function onConfigSet(evt){
// console.log('Config at '+evt.data.key+' changed!', field, evt.newval, evt);
field.update(evt.data.newval);
});
- field.addEventListener('change', function onFieldChange(evt){
+ field.on('change', function onFieldChange(evt){
// console.log('Field '+evt.data.key+' changed!', field, evt.newval, evt);
config.set(evt.data.key, evt.data.newval);
});
// Perform actions that should only happen once in Constructor
instance.__emitter__ = new Emitter(instance, cls);
- cls.fire('create', instance, {
+ cls.emit('create', instance, {
'instance' : instance,
'cls' : cls,
'args' : Y(args)
if ( isFunction(initialise) )
initialise.apply(instance, args);
- cls.fire('created', instance, {
+ cls.emit('created', instance, {
'instance' : instance,
'cls' : cls,
'args' : Y(args)
if (result) instance = result; // XXX: I think this needs to go away
}
- instance.fire('init', instance, {
+ instance.emit('init', instance, {
'instance' : instance,
'cls' : cls,
'args' : Y(arguments)
// Notify mixins to let them finish up any customization
if (mixins.length)
mixins.forEach(function(mxn){
- if ( mxn && isFunction(mxn.fire) )
- mxn.fire('mixin', NewClass, { 'mixin':mxn, 'cls':NewClass });
+ if ( mxn && isFunction(mxn.emit) )
+ mxn.emit('mixin', NewClass, { 'mixin':mxn, 'cls':NewClass });
});
// Notify parent of the subclass
- ParentEmitter.fire('subclass',
+ ParentEmitter.emit('subclass',
NewClass, {
'className' : className,
'parent' : Parent,
bases.unshift(mxn);
// Register onCreate to fire whenever a new instance is initialized
- if ( isFunction(cls.addEventListener) && hasOwn.call(mproto,'onCreate') && isFunction(onCreate) )
- cls.addEventListener('create', onCreate);
+ if ( isFunction(cls.on) && hasOwn.call(mproto,'onCreate') && isFunction(onCreate) )
+ cls.on('create', onCreate);
// Fire the mixin event on this Mixin only if we're done constructing the class
- if ( isFunction(mxn.fire) && mixin.caller !== Class )
- mxn.fire('mixin', cls, { 'mixin':mxn, 'cls':cls });
+ if ( isFunction(mxn.emit) && mixin.caller !== Class )
+ mxn.emit('mixin', cls, { 'mixin':mxn, 'cls':cls });
});
return cls;
}
-Mixin.addEventListener('subclass',
+Mixin.on('subclass',
function onMixinSubclass(evt){
var d = evt.data
, mxn = d.child
;
if ( isFunction(onMixin) )
- mxn.addEventListener('mixin', onMixin);
+ mxn.on('mixin', onMixin);
// console.log('Mixin.subclass()', mxn, '<', d.parent, 'onMixin:', onMixin);
});
this.running = true;
this.now = new Date().getTime() - (this.elapsedAtStop || this.targetTime);
- this.fire('start');
+ this.emit('start');
if (this.elapsedAtStop > 0)
this.sleepMinus(this.elapsedAtStop);
this.elapsedAtStop = Math.min(this.targetTime, new Date().getTime() - this.now);
this.timer = null;
this.running = false;
- this.fire('stop');
+ this.emit('stop');
},
sleepMinus : function sleepMinus(tFrame){
clearTimeout(this.timer);
this.timer = null;
- this.fire('tick', this, {
+ this.emit('tick', this, {
'now' : this.clock,
'elapsed' : this.perceived,
'ticks' : ++this.ticks
;
Species.__species_props__ = props;
- cls.fire('speciate', Species, { 'id':id, 'species':Species, 'cls':cls });
+ cls.emit('speciate', Species, { 'id':id, 'species':Species, 'cls':cls });
return Species;
},
},
load : function load(){
- this.fire('load');
+ this.emit('load');
jQuery.getJSON(this.path, this.process);
return this;
},
process : function process(data){
this.data = data;
- this.fire('process', data);
+ this.emit('process', data);
// console.group('DataFile: processing '+this.path);
var types = Y(data.types)
}, this);
// console.groupEnd();
- this.fire('complete');
+ this.emit('complete');
return this;
},
* @private
*/
die : function die(reason){
- this.fire('error', this, { 'reason':reason });
+ this.emit('error', this, { 'reason':reason });
throw new Error(this+' Error: '+reason);
},
start : function start(){
if (!this.running) {
this.running = true;
- this.fire('start');
+ this.emit('start');
this.nextJob();
}
return this;
*/
stop : function stop(){
if (this.running) {
- this.fire('stop');
+ this.emit('stop');
this.running = false;
}
return this;
&& self.queue.length === 0
&& self.inFlight.length === 0 ) {
self.running = false;
- self.fire('complete');
+ self.emit('complete');
return;
}
var job = self.queue.shift();
// console.log(self+'.nextJob() --> '+job);
- job.addEventListener('complete', function onJobComplete(evt){
+ job.on('complete', function onJobComplete(evt){
// console.log(self+'.onJobComplete('+job+')');
- job.removeEventListener('complete', arguments.callee);
+ job.removeListener('complete', arguments.callee);
self.inFlight.remove(job);
self.nextJob();
});
;
// Updates the midpoint square when square-size changes
-config.addEventListener('set:pathing.pathSquare', function(evt){
+config.on('set:pathing.pathSquare', function(evt){
var sq = evt.data.newval;
config.set('pathing.pathSquareMid', new Vec(sq/2, sq/2));
});
this.applyStatMods();
var data = { 'buff':this, 'unit':this.target, 'owner':this.owner };
- this.fire('buff.conjure', this.target, data);
- this.target.fire('buff.conjure', this, data);
+ this.emit('buff.conjure', this.target, data);
+ this.target.emit('buff.conjure', this, data);
},
tick : function tick(elapsed, now){
// var evt = 'buff.die.'+reason // We'll add this when we add polymorphic dispatchers
var evt = 'buff.die'
, data = { 'buff':this, 'unit':this.target, 'owner':this.owner };
- this.fire(evt, this.target, data);
- this.target.fire(evt, this, data);
+ this.emit(evt, this.target, data);
+ this.target.emit(evt, this, data);
return this;
},
});
-Buff.addEventListener('speciate',
+Buff.on('speciate',
function onSpeciate(evt){
var NewBuff = evt.data.species;
if (NewBuff.fn.timeout === -1)
this.viewport.append(this.map.ui);
// automatically keep track of units
- Thing.addEventListener('created', this.addUnit);
- Thing.addEventListener('destroy', this.killUnit);
- this.addEventListener('tick', this.tick);
+ Thing.on('created', this.addUnit);
+ Thing.on('destroy', this.killUnit);
+ this.on('tick', this.tick);
this.level.setup();
if (this.player) {
this.isReplay = true;
this.loadLog(replayFile);
} else
- this.fire('ready', this);
+ this.emit('ready', this);
},
destroy : function destroy(){
this.stop();
this.player.destroy();
- Thing.removeEventListener('created', this.addUnit);
- Thing.removeEventListener('destroy', this.killUnit);
+ Thing.removeListener('created', this.addUnit);
+ Thing.removeListener('destroy', this.killUnit);
this.root.remove();
this.resetGlobals();
},
if ( this.gameover )
setTimeout(function(){
- self.fire(self.gameover, self.player);
+ self.emit(self.gameover, self.player);
self.stop();
}, this.gameoverDelay);
},
return console.error('No replay data found!');
self.player.setReplay(replayData);
console.log('Replay loaded!');
- self.fire('ready', self);
+ self.emit('ready', self);
});
console.log('Loading replay log from //'+(window.location.host)+url+' ...');
return this;
evtName = 'item.move'
idx = item.ui.bpIdx;
- this._fireItemChange(evtName, item, { 'idx':idx, 'oldIdx':oldIdx });
+ this._emitItemChange(evtName, item, { 'idx':idx, 'oldIdx':oldIdx });
if ( displacedItem && displacedItem !== item ) {
displacedItem.ui.bpIdx = null;
this._putItem(displacedItem, oldIdx);
- this._fireItemChange('item.move', displacedItem, { 'idx':displacedItem.ui.bpIdx, 'oldIdx':idx });
+ this._emitItemChange('item.move', displacedItem, { 'idx':displacedItem.ui.bpIdx, 'oldIdx':idx });
}
return this;
if ( !this._removeItem(item) )
return null;
- this._fireItemChange('item.lose'+(drop ? '.drop' : ''), item, { 'idx':idx });
+ this._emitItemChange('item.lose'+(drop ? '.drop' : ''), item, { 'idx':idx });
return item;
},
eqs[slot] = item;
item.slot = slot;
- return this._fireItemChange('item.equip', item, { 'slot':slot });
+ return this._emitItemChange('item.equip', item, { 'slot':slot });
},
unequipSlot : function unequipSlot(slot, idx){
eqs[slot] = null;
item.slot = null;
- this._fireItemChange('item.unequip', item, { 'slot':slot, 'idx':idx });
+ this._emitItemChange('item.unequip', item, { 'slot':slot, 'idx':idx });
}
return this;
},
},
- _fireItemChange : function _fireItemChange(evt, item, data){
+ _emitItemChange : function _emitItemChange(evt, item, data){
data = Y.extend({ 'unit':this, 'item':item }, data || {});
- this.fire(evt, item, data);
- item.fire(evt, this, data);
+ this.emit(evt, item, data);
+ item.emit(evt, this, data);
return this;
}
proxy({ target:Level, donor:Rect, context:'shape', chain:true,
names:'append appendTo remove invoke clear'.split(' ') });
-Level.addEventListener('speciate',
+Level.on('speciate',
function onSpeciate(evt){
var NewLevel = evt.data.species
, proto = NewLevel.fn
collide : function collide(blocker){
var thing = this.thing;
- thing.fire('collide', blocker, { 'traversal':this, 'unit':blocker });
- blocker.fire('collide', thing, { 'traversal':this, 'unit':thing });
+ thing.emit('collide', blocker, { 'traversal':this, 'unit':blocker });
+ blocker.emit('collide', thing, { 'traversal':this, 'unit':thing });
},
rewind : function rewind(blocker){
});
// Divide on death (if possible)
-Rock.addEventListener('destroy', function(evt){
+Rock.on('destroy', function(evt){
var d = evt.data
, killer = d.killer
, side = d.side
});
Wall.register('wall', Wall);
-Wall.addEventListener('subclass',
+Wall.on('subclass',
function(evt){
var subcls = evt.data.child;
Wall.register(Y(subcls.className).camelToSnake(), subcls);
if ( !this._putItem(item, idx) )
return this;
- return this._fireItemChange('item.acquire', item, { 'idx':idx });
+ return this._emitItemChange('item.acquire', item, { 'idx':idx });
},
moveItem : function moveItem(item, idx){
return this;
idx = item.ui.bpIdx;
- this._fireItemChange('item.move', item, { 'idx':idx, 'oldIdx':oldIdx });
+ this._emitItemChange('item.move', item, { 'idx':idx, 'oldIdx':oldIdx });
if ( displacedItem && displacedItem !== item ) {
displacedItem.ui.bpIdx = null;
this._putItem(displacedItem, oldIdx);
- this._fireItemChange('item.move', displacedItem, { 'idx':displacedItem.ui.bpIdx, 'oldIdx':idx });
+ this._emitItemChange('item.move', displacedItem, { 'idx':displacedItem.ui.bpIdx, 'oldIdx':idx });
}
return true;
if ( this._removeItem(item) )
return this;
- this._fireItemChange('item.lose', item, { 'idx':idx });
+ this._emitItemChange('item.lose', item, { 'idx':idx });
return item;
},
if ( this._removeItem(item) )
return this;
- this._fireItemChange('item.lose.drop', item, { 'idx':idx });
+ this._emitItemChange('item.lose.drop', item, { 'idx':idx });
return item;
},
eqs[slot] = item;
item.slot = slot;
- return this._fireItemChange('item.equip', item, { 'slot':slot });
+ return this._emitItemChange('item.equip', item, { 'slot':slot });
},
unequipSlot : function unequipSlot(slot, idx){
eqs[slot] = null;
item.slot = null;
- this._fireItemChange('item.unequip', item, { 'slot':slot, 'idx':idx });
+ this._emitItemChange('item.unequip', item, { 'slot':slot, 'idx':idx });
}
return this;
},
},
- _fireItemChange : function _fireItemChange(evt, item, data){
+ _emitItemChange : function _emitItemChange(evt, item, data){
data = Y.extend({ 'unit':this, 'item':item }, data || {});
- this.fire(evt, item, data);
- item.fire(evt, this, data);
+ this.emit(evt, item, data);
+ item.emit(evt, this, data);
return this;
},
onCreate : function initQuantified(evt){
var self = evt.data.instance;
self.buffs = Y([]);
- self.addEventListener('buff.conjure', self.onBuffAcquired.bind(self));
- self.addEventListener('buff.die', self.onBuffLost.bind(self));
+ self.on('buff.conjure', self.onBuffAcquired.bind(self));
+ self.on('buff.die', self.onBuffLost.bind(self));
},
stat : function stat(k){
this.position(x1,y1);
this.trajectory = new Trajectory(this, x1,y1, x2,y2, this.movePerMs);
- this.addEventListener('collide', this.onCollide.bind(this));
+ this.on('collide', this.onCollide.bind(this));
},
createStats : function createStats(){
this.activateGauge = new CooldownGauge(this.cooldowns.activate, REF_SIZE+1,REF_SIZE+1);
- this.addEventListener('collide', this.onCollide);
- this.addEventListener('item.acquire', this.onAcquired);
- this.addEventListener('item.lose', this.onLost);
- this.addEventListener('item.equip', this.onEquip);
+ this.on('collide', this.onCollide);
+ this.on('item.acquire', this.onAcquired);
+ this.on('item.lose', this.onLost);
+ this.on('item.equip', this.onEquip);
},
/**
}
});
-Item.addEventListener('speciate',
+Item.on('speciate',
function onSpeciate(evt){
var NewItem = evt.data.species
, proto = NewItem.fn;
this.nShots++;
var p = new Projectile(this, tx,ty, x,y);
- p.addEventListener('destroy', this.onBulletDeath);
+ p.on('destroy', this.onBulletDeath);
return p;
};
function filterShoot(v){
destroy : function destroy(killer, side){
if (this.dead) return this;
this.dead = true;
- return this.remove().fire('destroy', this, { 'unit':this, 'killer':killer, 'side':side });
+ return this.remove().emit('destroy', this, { 'unit':this, 'killer':killer, 'side':side });
},
remove : function remove(){
};
// Persist config via cookies
-config.addEventListener('set', function(evt){
+config.on('set', function(evt){
// console.log('config.set', evt);
var d = evt.data;
if (d.newval !== d.defval)
return new BackpackSlot(this, idx).appendTo(this);
}, this);
- unit.addEventListener('item.acquire', this.onItemUpdated);
- unit.addEventListener('item.lose', this.onItemUpdated);
- unit.addEventListener('item.move', this.onItemUpdated);
+ unit.on('item.acquire', this.onItemUpdated);
+ unit.on('item.lose', this.onItemUpdated);
+ unit.on('item.move', this.onItemUpdated);
},
refresh : function refresh(){
this.slots = new Y(0, this.max).map(this._makeSlot, this);
if (this.defaultContainer) {
- unit.addEventListener('item.acquire', this.onItemUpdated);
- unit.addEventListener('item.lose', this.onItemUpdated);
- unit.addEventListener('item.move', this.onItemUpdated);
+ unit.on('item.acquire', this.onItemUpdated);
+ unit.on('item.lose', this.onItemUpdated);
+ unit.on('item.move', this.onItemUpdated);
}
},
return new BackpackSlot(this, idx).appendTo(this);
}, this);
- unit.addEventListener('item.acquire', this.onItemUpdated);
- unit.addEventListener('item.lose', this.onItemUpdated);
- unit.addEventListener('item.move', this.onItemUpdated);
+ unit.on('item.acquire', this.onItemUpdated);
+ unit.on('item.lose', this.onItemUpdated);
+ unit.on('item.move', this.onItemUpdated);
},
refresh : function refresh(){
overlay = $('#overlay');
updateOverlay( config.get('ui.overlayOnPause') );
- config.addEventListener('set:ui.overlayOnPause', function(evt){ updateOverlay(evt.newval); });
- config.addEventListener('set:ui.debug.showFpsGraph', function(evt){ updateUI('#info', evt.newval); });
+ config.on('set:ui.overlayOnPause', function(evt){ updateOverlay(evt.newval); });
+ config.on('set:ui.debug.showFpsGraph', function(evt){ updateUI('#info', evt.newval); });
- // Player.addEventListener('create', function(evt){ P = evt.data.instance; });
+ // Player.on('create', function(evt){ P = evt.data.instance; });
/// Debug ///
if (qkv.debug || config.get('debug.showFpsGraph'))
// Load all data files
cfg.dataLoader()
- .addEventListener('complete', function(evt){
+ .on('complete', function(evt){
$('#loading').hide();
$('#welcome').show();
setupGame();
P = game.player;
if (replayFile) {
- game.addEventListener('win', gameover('You Won the Replay!', 'Watch Again', ''));
- game.addEventListener('lose', gameover('You Lost the Replay :(', 'Watch Again', ''));
+ game.on('win', gameover('You Won the Replay!', 'Watch Again', ''));
+ game.on('lose', gameover('You Lost the Replay :(', 'Watch Again', ''));
} else {
- game.addEventListener('win', gameover('You Win!', 'Play Again', ''));
- game.addEventListener('lose', gameover('You Lose :(', 'Try Again', ''));
+ game.on('win', gameover('You Win!', 'Play Again', ''));
+ game.on('lose', gameover('You Lose :(', 'Try Again', ''));
}
ctx = game.level.ctx;
}
monitorAgent : function monitorAgent(agent){
if ( agent && !this.hasPath(agent.__id__) )
- agent.addEventListener('destroy', this.cleanUpAgent);
+ agent.on('destroy', this.cleanUpAgent);
},
cleanUpAgent : function cleanUpAgent(evt){ this.destroyPath(evt.target.__id__); },
projects / tanks.git / commitdiff