/// <summary>
/// Removes an event handler from the list
/// </summary>
/// <param name="e">The event from which to remove the handler</param>
/// <param name="del">The callback method to remove</param>
public void RemoveHandler(DOLEvent e, DOLEventHandler del)
{
if (_lock.TryEnterWriteLock(LOCK_TIMEOUT))
{
try
{
WeakMulticastDelegate deleg;
if (_events.TryGetValue(e, out deleg))
{
deleg = WeakMulticastDelegate.Remove(deleg, del);
if (deleg == null)
{
_events.Remove(e);
}
else
{
_events[e] = deleg;
}
}
}
finally
{
_lock.ExitWriteLock();
}
}
}
/// <summary>
/// Bainshee Transform While Casting.
/// </summary>
/// <param name="player"></param>
public override void Init(GamePlayer player)
{
base.Init(player);
// Add Cast Listener.
m_WraithTimerAction = new RegionTimerAction<GamePlayer>(Player, pl => { if (pl.CharacterClass is ClassBainshee) ((ClassBainshee)pl.CharacterClass).TurnOutOfWraith(); });
m_WraithTriggerEvent = new DOLEventHandler(TriggerUnWraithForm);
GameEventMgr.AddHandler(Player, GamePlayerEvent.CastFinished, new DOLEventHandler(TriggerWraithForm));
}
/// <summary>
/// Bainshee Transform While Casting.
/// </summary>
/// <param name="player"></param>
public override void Init(GamePlayer player)
{
base.Init(player);
// Add Cast Listener.
m_WraithTimerAction = new RegionTimerAction <GamePlayer>(Player, pl => { if (pl.CharacterClass is ClassBainshee)
{
((ClassBainshee)pl.CharacterClass).TurnOutOfWraith();
}
});
m_WraithTriggerEvent = new DOLEventHandler(TriggerUnWraithForm);
GameEventMgr.AddHandler(Player, GamePlayerEvent.CastFinished, new DOLEventHandler(TriggerWraithForm));
}
/// <summary>
/// Removes a global event handler.
/// You need to have registered the event before being able to remove it.
/// </summary>
/// <param name="e">The event type from which to deregister</param>
/// <param name="del">The event handler to deregister for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void RemoveHandler(DOLEvent e, DOLEventHandler del)
{
if (e == null)
{
throw new ArgumentNullException("e", "No event type given!");
}
if (del == null)
{
throw new ArgumentNullException("del", "No event handler given!");
}
m_globalHandlerCollection.RemoveHandler(e, del);
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="type">Triggertype</param>
/// <param name="k">keyword (K), meaning depends on triggertype</param>
/// <param name="i">variable (I), meaning depends on triggertype</param>
public AbstractTrigger(GameLiving defaultNPC, DOLEventHandler notifyHandler, eTriggerType type, object k, object i) : this(defaultNPC, notifyHandler, type)
{
TriggerAttribute attr = BehaviourMgr.getTriggerAttribute(this.GetType());
// handle parameter K
object defaultValueK = GetDefaultValue(attr.DefaultValueK);
this.k = (TypeK)BehaviourUtils.ConvertObject(k, defaultValueK, typeof(TypeK));
CheckParameter(K, attr.IsNullableK, typeof(TypeK));
// handle parameter I
object defaultValueI = GetDefaultValue(attr.DefaultValueI);
this.i = (TypeI)BehaviourUtils.ConvertObject(i, defaultValueI, typeof(TypeI));
CheckParameter(I, attr.IsNullableI, typeof(TypeI));
}
/// <summary>
/// Registers a single global event handler.
/// The global event handlers will be called for ALL events,
/// so use them wisely, they might incure a big performance
/// hit if used unwisely.
/// </summary>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <param name="unique">Flag wether event shall be added unique or not</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
private static void AddHandler(DOLEvent e, DOLEventHandler del, bool unique)
{
if (e == null)
{
throw new ArgumentNullException("e", "No event type given!");
}
if (del == null)
{
throw new ArgumentNullException("del", "No event handler given!");
}
if (unique)
{
m_globalHandlerCollection.AddHandlerUnique(e, del);
}
else
{
m_globalHandlerCollection.AddHandler(e, del);
}
}
/// <summary>
/// Removes a single event handler from an object.
/// You need to have registered the event before being
/// able to remove it.
/// </summary>
/// <param name="obj">The object that needs to be the sender of events</param>
/// <param name="e">The event type from which to deregister</param>
/// <param name="del">The event handler to deregister for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void RemoveHandler(object obj, DOLEvent e, DOLEventHandler del)
{
if (obj == null)
{
throw new ArgumentNullException("obj", "No object given!");
}
if (e == null)
{
throw new ArgumentNullException("e", "No event type given!");
}
if (del == null)
{
throw new ArgumentNullException("del", "No event handler given!");
}
DOLEventHandlerCollection col = null;
if (Lock.TryEnterReadLock(LOCK_TIMEOUT))
{
try
{
m_gameObjectEventCollections.TryGetValue(obj, out col);
}
finally
{
Lock.ExitReadLock();
}
}
else
{
log.ErrorFormat("Timeout exceeded on attempt to RemoveHandler for object: {0}, event: {1}", obj.ToString(), e.Name);
}
if (col != null)
{
col.RemoveHandler(e, del);
}
}
/// <summary>
/// Adds an event handler to the list.
/// </summary>
/// <param name="e">The event from which we add a handler</param>
/// <param name="del">The callback method</param>
public void AddHandler(DOLEvent e, DOLEventHandler del)
{
if (_lock.TryEnterWriteLock(LOCK_TIMEOUT))
{
try
{
WeakMulticastDelegate deleg;
if (!_events.TryGetValue(e, out deleg))
{
_events.Add(e, new WeakMulticastDelegate(del));
}
else
{
_events[e] = WeakMulticastDelegate.Combine(deleg, del);
}
}
finally
{
_lock.ExitWriteLock();
}
}
}
/// <summary>
/// Adds an event handler to the list.
/// </summary>
/// <param name="e">The event from which we add a handler</param>
/// <param name="del">The callback method</param>
public void AddHandler(DOLEvent e, DOLEventHandler del)
{
if(_lock.TryEnterWriteLock(LOCK_TIMEOUT))
{
try
{
WeakMulticastDelegate deleg;
if(!_events.TryGetValue(e, out deleg))
{
_events.Add(e, new WeakMulticastDelegate(del));
}
else
{
_events[e] = WeakMulticastDelegate.Combine(deleg, del);
}
}
finally
{
_lock.ExitWriteLock();
}
}
}
/// <summary>
/// Registers a single global event handler.
/// The global event handlers will be called for ALL events,
/// so use them wisely, they might incure a big performance
/// hit if used unwisely.
/// If an equal handler has already been added, nothing will be done
/// </summary>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void AddHandlerUnique(DOLEvent e, DOLEventHandler del)
{
AddHandler(e, del, true);
}
/// <summary>
/// Creates a Behaviour for the given default npc.
/// </summary>
/// <param name="npc">NPC associated with his behaviour typically NPC talking to or mob killing, etc...</param>
public BaseBehaviour(GameNPC npc)
{
this.NPC = npc;
NotifyHandler = new DOLEventHandler(this.Notify);
}
/// <summary>
/// Registers a single object event handler.
/// The global event handlers will be called for ALL events,
/// so use them wisely, they might incure a big performance
/// hit if used unwisely.
/// If an equal handler has already been added, nothing will be done
/// </summary>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void AddHandlerUnique(object obj, DOLEvent e, DOLEventHandler del)
{
AddHandler(obj, e, del, true);
}
public void UnRegisterPlayerEnter(DOLEventHandler callback)
{
GameEventMgr.RemoveHandler(this, AreaEvent.PlayerEnter, callback);
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defautNpc"></param>
/// <param name="notifyHandler"></param>
/// <param name="questType"></param>
public AcceptQuestTrigger(GameNPC defautNpc, DOLEventHandler notifyHandler, Type questType)
: this(defautNpc, notifyHandler, null, questType)
{
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="questType"></param>
public AbortQuestTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, Type questType)
: this(defaultNPC, notifyHandler, (object)null, (object)questType)
{
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="k"></param>
/// <param name="i"></param>
public EnemyDyingTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, string k, GameLiving i)
: this(defaultNPC, notifyHandler, (object)k, (object)i)
{
}
/// <summary>
/// Removes a single event handler from an object.
/// You need to have registered the event before being
/// able to remove it.
/// </summary>
/// <param name="obj">The object that needs to be the sender of events</param>
/// <param name="e">The event type from which to deregister</param>
/// <param name="del">The event handler to deregister for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void RemoveHandler(object obj, DOLEvent e, DOLEventHandler del)
{
if(obj == null)
throw new ArgumentNullException("obj", "No object given!");
if(e == null)
throw new ArgumentNullException("e", "No event type given!");
if(del == null)
throw new ArgumentNullException("del", "No event handler given!");
DOLEventHandlerCollection col = null;
if (Lock.TryEnterReadLock(LOCK_TIMEOUT))
{
try
{
m_gameObjectEventCollections.TryGetValue(obj, out col);
}
finally
{
Lock.ExitReadLock();
}
}
else
{
log.ErrorFormat("Timeout exceeded on attempt to RemoveHandler for object: {0}, event: {1}", obj.ToString(), e.Name);
}
if (col != null)
{
col.RemoveHandler(e, del);
}
}
/// <summary>
/// Registers a single local event handler.
/// Local event handlers will only be called if the
/// "sender" parameter in the Notify method equals
/// the object for which a local event handler was
/// registered.
/// </summary>
/// <remarks>
/// Certain events will never have a local event handler.
/// This happens if the Notify method is called without
/// a sender parameter for example!
/// </remarks>
/// <param name="obj">The object that needs to be the sender of events</param>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <param name="unique">Flag wether event shall be added unique or not</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
private static void AddHandler(object obj, DOLEvent e, DOLEventHandler del, bool unique)
{
if(obj == null)
throw new ArgumentNullException("obj", "No object given!");
if(e == null)
throw new ArgumentNullException("e", "No event type given!");
if(del == null)
throw new ArgumentNullException("del", "No event handler given!");
if(!e.IsValidFor(obj))
throw new ArgumentException("Object is not valid for this event type", "obj");
if(Lock.TryEnterUpgradeableReadLock(LOCK_TIMEOUT))
{
try
{
DOLEventHandlerCollection col;
if(!m_gameObjectEventCollections.TryGetValue(obj, out col))
{
col = new DOLEventHandlerCollection();
if (Lock.TryEnterWriteLock(LOCK_TIMEOUT))
{
try
{
m_gameObjectEventCollections.Add(obj, col);
}
finally
{
Lock.ExitWriteLock();
}
}
else
{
log.ErrorFormat("Timeout exceeded on attempt to AddHandler for object: {0}, event: {1}", obj.ToString(), e.Name);
}
}
if(unique)
{
col.AddHandlerUnique(e, del);
}
else
{
col.AddHandler(e, del);
}
}
finally
{
Lock.ExitUpgradeableReadLock();
}
}
}
/// <summary>
/// Registers a single global event handler.
/// The global event handlers will be called for ALL events,
/// so use them wisely, they might incure a big performance
/// hit if used unwisely.
/// </summary>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <param name="unique">Flag wether event shall be added unique or not</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
private static void AddHandler(DOLEvent e, DOLEventHandler del, bool unique)
{
if(e == null)
throw new ArgumentNullException("e", "No event type given!");
if(del == null)
throw new ArgumentNullException("del", "No event handler given!");
if(unique)
{
m_globalHandlerCollection.AddHandlerUnique(e, del);
}
else
{
m_globalHandlerCollection.AddHandler(e, del);
}
}
/// <summary>
/// Registers a single local event handler.
/// Local event handlers will only be called if the
/// "sender" parameter in the Notify method equals
/// the object for which a local event handler was
/// registered.
/// </summary>
/// <remarks>
/// Certain events will never have a local event handler.
/// This happens if the Notify method is called without
/// a sender parameter for example!
/// </remarks>
/// <param name="obj">The object that needs to be the sender of events</param>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <param name="unique">Flag wether event shall be added unique or not</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
private static void AddHandler(object obj, DOLEvent e, DOLEventHandler del, bool unique)
{
if (obj == null)
{
throw new ArgumentNullException("obj", "No object given!");
}
if (e == null)
{
throw new ArgumentNullException("e", "No event type given!");
}
if (del == null)
{
throw new ArgumentNullException("del", "No event handler given!");
}
if (!e.IsValidFor(obj))
{
throw new ArgumentException("Object is not valid for this event type", "obj");
}
if (Lock.TryEnterUpgradeableReadLock(LOCK_TIMEOUT))
{
try
{
DOLEventHandlerCollection col;
if (!m_gameObjectEventCollections.TryGetValue(obj, out col))
{
col = new DOLEventHandlerCollection();
if (Lock.TryEnterWriteLock(LOCK_TIMEOUT))
{
try
{
m_gameObjectEventCollections.Add(obj, col);
}
finally
{
Lock.ExitWriteLock();
}
}
else
{
log.ErrorFormat("Timeout exceeded on attempt to AddHandler for object: {0}, event: {1}", obj.ToString(), e.Name);
}
}
if (unique)
{
col.AddHandlerUnique(e, del);
}
else
{
col.AddHandler(e, del);
}
}
finally
{
Lock.ExitUpgradeableReadLock();
}
}
}
/// <summary>
/// Registers a single local event handler.
/// Local event handlers will only be called if the
/// "sender" parameter in the Notify method equals
/// the object for which a local event handler was
/// registered.
/// </summary>
/// <remarks>
/// Certain events will never have a local event handler.
/// This happens if the Notify method is called without
/// a sender parameter for example!
/// </remarks>
/// <param name="obj">The object that needs to be the sender of events</param>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void AddHandler(object obj, DOLEvent e, DOLEventHandler del)
{
AddHandler(obj, e, del, false);
}
/// <summary>
/// Registers a single global event handler.
/// The global event handlers will be called for ALL events,
/// so use them wisely, they might incure a big performance
/// hit if used unwisely.
/// </summary>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void AddHandler(DOLEvent e, DOLEventHandler del)
{
AddHandler(e, del, false);
}
/// <summary>
/// Registers a single object event handler.
/// The global event handlers will be called for ALL events,
/// so use them wisely, they might incure a big performance
/// hit if used unwisely.
/// If an equal handler has already been added, nothing will be done
/// </summary>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void AddHandlerUnique(object obj, DOLEvent e, DOLEventHandler del)
{
AddHandler(obj, e, del, true);
}
/// <summary>
/// Registers a single global event handler.
/// The global event handlers will be called for ALL events,
/// so use them wisely, they might incure a big performance
/// hit if used unwisely.
/// If an equal handler has already been added, nothing will be done
/// </summary>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void AddHandlerUnique(DOLEvent e, DOLEventHandler del)
{
AddHandler(e, del, true);
}
/// <summary>
/// Registers a single local event handler.
/// Local event handlers will only be called if the
/// "sender" parameter in the Notify method equals
/// the object for which a local event handler was
/// registered.
/// </summary>
/// <remarks>
/// Certain events will never have a local event handler.
/// This happens if the Notify method is called without
/// a sender parameter for example!
/// </remarks>
/// <param name="obj">The object that needs to be the sender of events</param>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void AddHandler(object obj, DOLEvent e, DOLEventHandler del)
{
AddHandler(obj, e, del, false);
}
/// <summary>
/// Removes an event handler from the list
/// </summary>
/// <param name="e">The event from which to remove the handler</param>
/// <param name="del">The callback method to remove</param>
public void RemoveHandler(DOLEvent e, DOLEventHandler del)
{
if(_lock.TryEnterWriteLock(LOCK_TIMEOUT))
{
try
{
WeakMulticastDelegate deleg;
if(_events.TryGetValue(e, out deleg))
{
deleg = WeakMulticastDelegate.Remove(deleg, del);
if(deleg == null)
{
_events.Remove(e);
}
else
{
_events[e] = deleg;
}
}
}
finally
{
_lock.ExitWriteLock();
}
}
}
/// <summary>
/// Removes a global event handler.
/// You need to have registered the event before being able to remove it.
/// </summary>
/// <param name="e">The event type from which to deregister</param>
/// <param name="del">The event handler to deregister for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void RemoveHandler(DOLEvent e, DOLEventHandler del)
{
if(e == null)
throw new ArgumentNullException("e", "No event type given!");
if(del == null)
throw new ArgumentNullException("del", "No event handler given!");
m_globalHandlerCollection.RemoveHandler(e, del);
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="k"></param>
/// <param name="i"></param>
public InteractTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, Object k, Object i)
: base(defaultNPC, notifyHandler, eTriggerType.Interact, k, i)
{
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="k"></param>
/// <param name="i"></param>
public EnemyDyingTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, Object k, Object i)
: base(defaultNPC, notifyHandler, eTriggerType.EnemyDying, k, i)
{
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="i"></param>
public InteractTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, GameNPC i)
: this(defaultNPC, notifyHandler, (object)null, (object)i)
{
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="k"></param>
/// <param name="i"></param>
public AbortQuestTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, Object k, Object i)
: base(defaultNPC, notifyHandler, eTriggerType.AbortQuest, k, i)
{
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="k">keyword (K), meaning depends on triggertype</param>
/// <param name="i">variable (I), meaning depends on triggertype</param>
public EnterAreaTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, Object k, Object i)
: base(defaultNPC, notifyHandler, eTriggerType.EnterArea, k, i)
{
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNpc"></param>
/// <param name="notifyHandler"></param>
/// <param name="k"></param>
/// <param name="i"></param>
public AcceptQuestTrigger(GameNPC defaultNpc, DOLEventHandler notifyHandler, object k, object i)
: base(defaultNpc, notifyHandler, eTriggerType.AcceptQuest, k, i)
{
}
public void UnRegisterPlayerEnter(DOLEventHandler callback)
{
GameEventMgr.RemoveHandler(this, AreaEvent.PlayerEnter, callback);
}
/// <summary>
/// Creates a Behaviour for the given default npc.
/// </summary>
/// <param name="npc">NPC associated with his behaviour typically NPC talking to or mob killing, etc...</param>
public BaseBehaviour(GameNPC npc)
{
this.NPC = npc;
NotifyHandler = new DOLEventHandler(this.Notify);
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="k"></param>
/// <param name="i"></param>
public WhisperTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, Object k, Object i)
: base(defaultNPC, notifyHandler, eTriggerType.Whisper, k, i)
{
}
public void RegisterPlayerLeave(DOLEventHandler callback)
{
GameEventMgr.AddHandler(this, AreaEvent.PlayerLeave, callback);
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="k"></param>
public TimerTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, string k)
: this(defaultNPC, notifyHandler, (object)k, (object)null)
{
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="i">variable (I), meaning depends on triggertype</param>
public EnterAreaTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, IArea i)
: this(defaultNPC, notifyHandler, (object)null, (object)i)
{
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="type"></param>
public AbstractTrigger(GameLiving defaultNPC, DOLEventHandler notifyHandler, eTriggerType type)
{
this.defaultNPC = defaultNPC;
this.notifyHandler = notifyHandler;
this.triggerType = type;
}
public void RegisterPlayerLeave(DOLEventHandler callback)
{
GameEventMgr.AddHandler(this, AreaEvent.PlayerLeave, callback);
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="k"></param>
/// <param name="i"></param>
public EnemyKilledTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, object k, object i)
: base(defaultNPC, notifyHandler, eTriggerType.EnemyKilled, k, i)
{
}
/// <summary>
/// Creates a new questtrigger and does some simple triggertype parameter compatibility checking
/// </summary>
/// <param name="defaultNPC"></param>
/// <param name="notifyHandler"></param>
/// <param name="k"></param>
/// <param name="i"></param>
public WhisperTrigger(GameNPC defaultNPC, DOLEventHandler notifyHandler, string k, GameNPC i)
: this(defaultNPC, notifyHandler, (object)k, (object)i)
{
}
/// <summary>
/// Registers a single global event handler.
/// The global event handlers will be called for ALL events,
/// so use them wisely, they might incure a big performance
/// hit if used unwisely.
/// </summary>
/// <param name="e">The event type to register for</param>
/// <param name="del">The event handler to register for this event type</param>
/// <exception cref="ArgumentNullException">If one of the parameters is null</exception>
public static void AddHandler(DOLEvent e, DOLEventHandler del)
{
AddHandler(e, del, false);
}
