BETA: Implementing more event listeners and reworking existing ones:

	* Re-implemented events:
		* onAttack()
		* onSkillUse()
		* onDeath()
	* New implemented events:
		* onKarmaChange() fired whenever current player's karma points has been changed.
		* onPKPointsChange() fired whenever current player's pk points has been changed.
		* onPvPPointsChange() fired whenever current player's pvp points has been.
		* onFamePointsChange() fired whenever current player's fame points has been changed.
	* Fixed little typo that could cause not getting static listeners triggered if non static wasn't registered.
	* Fixed vulnerability of exceptions to get passed to their notificators and interupt current action.
	* Reviewed by: Zoey76

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/L2Character.java

@@ -67,7 +67,6 @@ import com.l2jserver.gameserver.model.Location;
 import com.l2jserver.gameserver.model.PcCondOverride;
 import com.l2jserver.gameserver.model.ShotType;
 import com.l2jserver.gameserver.model.actor.events.CharEvents;
-import com.l2jserver.gameserver.model.actor.instance.L2NpcInstance;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.model.actor.instance.L2PetInstance;
 import com.l2jserver.gameserver.model.actor.instance.L2RiftInvaderInstance;
@@ -127,12 +126,6 @@ import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
 import com.l2jserver.gameserver.network.serverpackets.TeleportToLocation;
 import com.l2jserver.gameserver.pathfinding.AbstractNodeLoc;
 import com.l2jserver.gameserver.pathfinding.PathFinding;
-import com.l2jserver.gameserver.scripting.scriptengine.events.AttackEvent;
-import com.l2jserver.gameserver.scripting.scriptengine.events.DeathEvent;
-import com.l2jserver.gameserver.scripting.scriptengine.events.SkillUseEvent;
-import com.l2jserver.gameserver.scripting.scriptengine.listeners.character.AttackListener;
-import com.l2jserver.gameserver.scripting.scriptengine.listeners.character.DeathListener;
-import com.l2jserver.gameserver.scripting.scriptengine.listeners.character.SkillUseListener;
 import com.l2jserver.gameserver.taskmanager.AttackStanceTaskManager;
 import com.l2jserver.gameserver.util.L2TIntObjectHashMap;
 import com.l2jserver.gameserver.util.Point3D;
@@ -163,12 +156,6 @@ public abstract class L2Character extends L2Object implements ISkillsHolder
 {
 	public static final Logger _log = Logger.getLogger(L2Character.class.getName());
 	
-	private static List<DeathListener> globalDeathListeners = new FastList<DeathListener>().shared();
-	private static List<SkillUseListener> globalSkillUseListeners = new FastList<SkillUseListener>().shared();
-	private final List<AttackListener> attackListeners = new FastList<AttackListener>().shared();
-	private final List<DeathListener> deathListeners = new FastList<DeathListener>().shared();
-	private final List<SkillUseListener> skillUseListeners = new FastList<SkillUseListener>().shared();
-	
 	private volatile Set<L2Character> _attackByList;
 	private volatile boolean _isCastingNow = false;
 	private volatile boolean _isCastingSimultaneouslyNow = false;
@@ -789,7 +776,7 @@ public abstract class L2Character extends L2Object implements ISkillsHolder
 	 */
 	protected void doAttack(L2Character target)
 	{
-		if ((target == null) || isAttackingDisabled() || !fireAttackListeners(target))
+		if ((target == null) || isAttackingDisabled() || !getEvents().onAttack(target))
 		{
 			return;
 		}
@@ -1702,7 +1689,7 @@ public abstract class L2Character extends L2Object implements ISkillsHolder
 	
 	private void beginCast(L2Skill skill, boolean simultaneously, L2Character target, L2Object[] targets)
 	{
-		if (target == null)
+		if ((target == null) || !getEvents().onMagic(skill, simultaneously, target, targets))
 		{
 			if (simultaneously)
 			{
@@ -1720,11 +1707,7 @@ public abstract class L2Character extends L2Object implements ISkillsHolder
 			return;
 		}
 		
-		if (!fireSkillCastListeners(skill, simultaneously, target, targets))
-		{
-			return;
-		}
-		
+		// TODO: Unhardcode using event listeners!
 		if (skill.getSkillType() == L2SkillType.RESURRECT)
 		{
 			if (isResurrectionBlocked() || target.isResurrectionBlocked())
@@ -7612,269 +7595,4 @@ public abstract class L2Character extends L2Object implements ISkillsHolder
 		getEvents().onDamageReceived(damage, attacker, skill, critical);
 		attacker.getEvents().onDamageDealt(damage, this, skill, critical);
 	}
-	
-	// LISTENERS
-	
-	/**
-	 * Fires the attack listeners, if any. Returns false if the attack is to be blocked.
-	 * @param target
-	 * @return
-	 */
-	private boolean fireAttackListeners(L2Character target)
-	{
-		if ((target != null) && (!attackListeners.isEmpty() || !target.getAttackListeners().isEmpty()))
-		{
-			AttackEvent event = new AttackEvent();
-			event.setTarget(target);
-			event.setAttacker(this);
-			for (AttackListener listener : attackListeners)
-			{
-				if (!listener.onAttack(event))
-				{
-					return false;
-				}
-			}
-			for (AttackListener listener : target.getAttackListeners())
-			{
-				if (!listener.isAttacked(event))
-				{
-					return false;
-				}
-			}
-		}
-		return true;
-	}
-	
-	/**
-	 * Fires the skill cast listeners, if any. Returns false if the attack is to be blocked.
-	 * @param skill
-	 * @param simultaneously
-	 * @param target
-	 * @param targets
-	 * @return
-	 */
-	private boolean fireSkillCastListeners(L2Skill skill, boolean simultaneously, L2Character target, L2Object[] targets)
-	{
-		if ((skill != null) && ((target != null) || (targets.length != 0)) && (!skillUseListeners.isEmpty() || !globalSkillUseListeners.isEmpty()))
-		{
-			int arraySize = (target == null ? 0 : 1) + (targets == null ? 0 : targets.length);
-			L2Object[] t = new L2Object[arraySize];
-			int i = 0;
-			if (target != null)
-			{
-				t[0] = target;
-				i++;
-			}
-			if (targets != null)
-			{
-				System.arraycopy(targets, 0, t, i, targets.length);
-				
-				if (targets.length > 0)
-				{
-					SkillUseEvent event = new SkillUseEvent();
-					event.setCaster(this);
-					event.setSkill(skill);
-					event.setTargets(t);
-					for (SkillUseListener listener : skillUseListeners)
-					{
-						int skillId = skill.getId();
-						if ((listener.getSkillId() == -1) || (skillId == listener.getSkillId()))
-						{
-							if (!listener.onSkillUse(event))
-							{
-								return false;
-							}
-						}
-					}
-					for (SkillUseListener listener : globalSkillUseListeners)
-					{
-						int npcId = listener.getNpcId();
-						int skillId = listener.getSkillId();
-						boolean skillOk = (skillId == -1) || (skillId == skill.getId());
-						boolean charOk = ((npcId == -1) && (this instanceof L2NpcInstance)) || ((npcId == -2) && isPlayer()) || (npcId == -3) || ((this instanceof L2NpcInstance) && (((L2NpcInstance) this).getNpcId() == npcId));
-						if (skillOk && charOk)
-						{
-							if (!listener.onSkillUse(event))
-							{
-								return false;
-							}
-						}
-					}
-				}
-			}
-		}
-		return true;
-	}
-	
-	/**
-	 * Fires the death listeners, if any.<br>
-	 * If it returns false, the doDie method will return false (and the L2Character wont die)<br>
-	 * The method is public so that L2Playable can access it.
-	 * @param killer
-	 * @return
-	 */
-	public boolean fireDeathListeners(L2Character killer)
-	{
-		if ((killer != null) && (!deathListeners.isEmpty() || !globalDeathListeners.isEmpty() || !killer.getDeathListeners().isEmpty()))
-		{
-			DeathEvent event = new DeathEvent();
-			event.setKiller(killer);
-			event.setVictim(this);
-			for (DeathListener listener : deathListeners)
-			{
-				if (!listener.onDeath(event))
-				{
-					return false;
-				}
-			}
-			for (DeathListener listener : killer.getDeathListeners())
-			{
-				if (!listener.onKill(event))
-				{
-					return false;
-				}
-			}
-			for (DeathListener listener : globalDeathListeners)
-			{
-				if (killer.isPlayer() || isPlayer())
-				{
-					if (!listener.onDeath(event))
-					{
-						return false;
-					}
-					
-				}
-			}
-		}
-		return true;
-	}
-	
-	/**
-	 * Adds an attack listener
-	 * @param listener
-	 */
-	public void addAttackListener(AttackListener listener)
-	{
-		if (!attackListeners.contains(listener))
-		{
-			attackListeners.add(listener);
-		}
-	}
-	
-	/**
-	 * Removes an attack listener
-	 * @param listener
-	 */
-	public void removeAttackListener(AttackListener listener)
-	{
-		attackListeners.remove(listener);
-	}
-	
-	/**
-	 * Returns the attack listeners
-	 * @return
-	 */
-	public List<AttackListener> getAttackListeners()
-	{
-		return attackListeners;
-	}
-	
-	/**
-	 * Adds a death listener.<br>
-	 * Triggered when this char kills another char, and when this char gets killed by another char.
-	 * @param listener
-	 */
-	public void addDeathListener(DeathListener listener)
-	{
-		if (!deathListeners.contains(listener))
-		{
-			deathListeners.add(listener);
-		}
-	}
-	
-	/**
-	 * removes a death listener
-	 * @param listener
-	 */
-	public void removeDeathListener(DeathListener listener)
-	{
-		deathListeners.remove(listener);
-	}
-	
-	/**
-	 * Returns the death listeners
-	 * @return
-	 */
-	public List<DeathListener> getDeathListeners()
-	{
-		return deathListeners;
-	}
-	
-	/**
-	 * Adds a global death listener
-	 * @param listener
-	 */
-	public static void addGlobalDeathListener(DeathListener listener)
-	{
-		if (!globalDeathListeners.contains(listener))
-		{
-			globalDeathListeners.add(listener);
-		}
-	}
-	
-	public static List<DeathListener> getGlobalDeathListeners()
-	{
-		return globalDeathListeners;
-	}
-	
-	/**
-	 * Removes a global death listener
-	 * @param listener
-	 */
-	public static void removeGlobalDeathListener(DeathListener listener)
-	{
-		globalDeathListeners.remove(listener);
-	}
-	
-	/**
-	 * Adds a skill use listener
-	 * @param listener
-	 */
-	public void addSkillUseListener(SkillUseListener listener)
-	{
-		if (!skillUseListeners.contains(listener))
-		{
-			skillUseListeners.add(listener);
-		}
-	}
-	
-	/**
-	 * Removes a skill use listener
-	 * @param listener
-	 */
-	public void removeSkillUseListener(SkillUseListener listener)
-	{
-		skillUseListeners.remove(listener);
-	}
-	
-	/**
-	 * Adds a global skill use listener
-	 * @param listener
-	 */
-	public static void addGlobalSkillUseListener(SkillUseListener listener)
-	{
-		if (!globalSkillUseListeners.contains(listener))
-		{
-			globalSkillUseListeners.add(listener);
-		}
-	}
-	
-	/**
-	 * Removes a global skill use listener
-	 * @param listener
-	 */
-	public static void removeGlobalSkillUseListener(SkillUseListener listener)
-	{
-		globalSkillUseListeners.remove(listener);
-	}
 }

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/events/AbstractCharEvents.java

@@ -123,19 +123,27 @@ public abstract class AbstractCharEvents
 		return _listeners != null;
 	}
 	
+	protected final boolean hasListeners()
+	{
+		return (_listeners != null) || (_staticListeners != null);
+	}
+	
 	protected final <T> List<T> getEventListeners(Class<T> clazz)
 	{
-		if (!hasEventListeners() && !hasStaticEventListeners())
+		if (!hasListeners())
 		{
 			return Collections.<T> emptyList();
 		}
 		
 		final List<T> listeners = new ArrayList<>();
-		for (IEventListener listener : _listeners)
+		if (hasEventListeners())
 		{
-			if (clazz.isInstance(listener))
+			for (IEventListener listener : _listeners)
 			{
-				listeners.add(clazz.cast(listener));
+				if (clazz.isInstance(listener))
+				{
+					listeners.add(clazz.cast(listener));
+				}
 			}
 		}
 		

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/events/CharEvents.java

@@ -18,12 +18,16 @@
  */
 package com.l2jserver.gameserver.model.actor.events;
 
+import java.util.logging.Level;
 import java.util.logging.Logger;
 
+import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.events.listeners.IAttackEventListener;
 import com.l2jserver.gameserver.model.actor.events.listeners.IDamageDealtEventListener;
 import com.l2jserver.gameserver.model.actor.events.listeners.IDamageReceivedEventListener;
 import com.l2jserver.gameserver.model.actor.events.listeners.IDeathEventListener;
+import com.l2jserver.gameserver.model.actor.events.listeners.ISkillUseEventListener;
 import com.l2jserver.gameserver.model.actor.events.listeners.ITeleportedEventListener;
 import com.l2jserver.gameserver.model.skills.L2Skill;
 
@@ -41,6 +45,65 @@ public class CharEvents extends AbstractCharEvents
 		_activeChar = activeChar;
 	}
 	
+	/**
+	 * Fired whenever current char attacks someone.
+	 * @param target
+	 * @return {@code true} if current attack is possible, {@code false} otherwise.
+	 */
+	public boolean onAttack(L2Character target)
+	{
+		if (hasListeners())
+		{
+			for (IAttackEventListener listener : getEventListeners(IAttackEventListener.class))
+			{
+				try
+				{
+					if (!listener.onAttack(getActingPlayer(), target))
+					{
+						return false;
+					}
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
+			}
+		}
+		return true;
+	}
+	
+	/**
+	 * Fired whenever current char cast a magic.
+	 * @param skill
+	 * @param simultaneously
+	 * @param target
+	 * @param targets
+	 * @return {@code true} if cast can be made, {@code false} otherwise.
+	 */
+	public boolean onMagic(L2Skill skill, boolean simultaneously, L2Character target, L2Object[] targets)
+	{
+		if (hasListeners())
+		{
+			for (ISkillUseEventListener listener : getEventListeners(ISkillUseEventListener.class))
+			{
+				try
+				{
+					if (!listener.onSkillUse(getActingPlayer(), skill, simultaneously, target, targets))
+					{
+						return false;
+					}
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
+			}
+		}
+		return true;
+	}
+	
 	/**
 	 * Fired whenever current char dies.
 	 * @param killer
@@ -48,17 +111,22 @@ public class CharEvents extends AbstractCharEvents
 	 */
 	public boolean onDeath(L2Character killer)
 	{
-		if (!getActingPlayer().fireDeathListeners(killer))
-		{
-			return false;
-		}
-		
-		// Notify event listeners.
-		if (hasEventListeners())
+		if (hasListeners())
 		{
 			for (IDeathEventListener listener : getEventListeners(IDeathEventListener.class))
 			{
-				listener.onDeath(getActingPlayer(), killer);
+				try
+				{
+					if (!listener.onDeath(getActingPlayer(), killer))
+					{
+						return false;
+					}
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
 			}
 		}
 		return true;
@@ -73,11 +141,19 @@ public class CharEvents extends AbstractCharEvents
 	 */
 	public void onDamageDealt(double damage, L2Character target, L2Skill skill, boolean crit)
 	{
-		if (hasEventListeners())
+		if (hasListeners())
 		{
 			for (IDamageDealtEventListener listener : getEventListeners(IDamageDealtEventListener.class))
 			{
-				listener.onDamageDealtEvent(getActingPlayer(), target, damage, skill, crit);
+				try
+				{
+					listener.onDamageDealtEvent(getActingPlayer(), target, damage, skill, crit);
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
 			}
 		}
 	}
@@ -91,11 +167,19 @@ public class CharEvents extends AbstractCharEvents
 	 */
 	public void onDamageReceived(double damage, L2Character attacker, L2Skill skill, boolean crit)
 	{
-		if (hasEventListeners())
+		if (hasListeners())
 		{
 			for (IDamageReceivedEventListener listener : getEventListeners(IDamageReceivedEventListener.class))
 			{
-				listener.onDamageReceivedEvent(attacker, getActingPlayer(), damage, skill, crit);
+				try
+				{
+					listener.onDamageReceivedEvent(attacker, getActingPlayer(), damage, skill, crit);
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
 			}
 		}
 	}
@@ -105,20 +189,23 @@ public class CharEvents extends AbstractCharEvents
 	 */
 	public void onTeleported()
 	{
-		if (hasEventListeners())
+		if (hasListeners())
 		{
 			for (ITeleportedEventListener listener : getEventListeners(ITeleportedEventListener.class))
 			{
-				listener.onTeleported(getActingPlayer());
+				try
+				{
+					listener.onTeleported(getActingPlayer());
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
 			}
 		}
 	}
 	
-	public boolean onExperienceReceived(long exp)
-	{
-		return true;
-	}
-	
 	/**
 	 * @return current char.
 	 */

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/events/PlayableEvents.java

@@ -18,6 +18,8 @@
  */
 package com.l2jserver.gameserver.model.actor.events;
 
+import java.util.logging.Level;
+
 import com.l2jserver.gameserver.model.actor.L2Playable;
 import com.l2jserver.gameserver.model.actor.events.listeners.IExperienceReceivedEventListener;
 
@@ -31,17 +33,32 @@ public class PlayableEvents extends CharEvents
 		super(activeChar);
 	}
 	
-	@Override
+	/**
+	 * Fired whenever current char receives any exp.
+	 * @param exp
+	 * @return {@code true} if experience can be received, {@code false} otherwise.
+	 */
 	public boolean onExperienceReceived(long exp)
 	{
-		if (hasEventListeners())
+		if (hasListeners())
 		{
 			for (IExperienceReceivedEventListener listener : getEventListeners(IExperienceReceivedEventListener.class))
 			{
-				listener.onExperienceReceived(getActingPlayer(), exp);
+				try
+				{
+					if (!listener.onExperienceReceived(getActingPlayer(), exp))
+					{
+						return false;
+					}
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
 			}
 		}
-		return super.onExperienceReceived(exp);
+		return true;
 	}
 	
 	@Override

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/events/PlayerEvents.java

@@ -18,6 +18,12 @@
  */
 package com.l2jserver.gameserver.model.actor.events;
 
+import java.util.logging.Level;
+
+import com.l2jserver.gameserver.model.actor.events.listeners.IFamePointsChangeEventListener;
+import com.l2jserver.gameserver.model.actor.events.listeners.IKarmaChangeEventListener;
+import com.l2jserver.gameserver.model.actor.events.listeners.IPKPointsChangeEventListener;
+import com.l2jserver.gameserver.model.actor.events.listeners.IPvPPointsEventChange;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 /**
@@ -35,4 +41,120 @@ public class PlayerEvents extends PlayableEvents
 	{
 		return (L2PcInstance) super.getActingPlayer();
 	}
+	
+	/**
+	 * Fired whenever player's karma points has change.
+	 * @param oldKarma
+	 * @param newKarma
+	 * @return {@code true} if karma change is possible, {@code false} otherwise.
+	 */
+	public boolean onKarmaChange(int oldKarma, int newKarma)
+	{
+		if (hasListeners())
+		{
+			for (IKarmaChangeEventListener listener : getEventListeners(IKarmaChangeEventListener.class))
+			{
+				try
+				{
+					if (!listener.onKarmaChange(getActingPlayer(), oldKarma, newKarma))
+					{
+						return false;
+					}
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
+			}
+		}
+		return true;
+	}
+	
+	/**
+	 * Fired whenever player's pk points has change.
+	 * @param oldPKPoints
+	 * @param newPKPoints
+	 * @return {@code true} if pk points change is possible, {@code false} otherwise.
+	 */
+	public boolean onPKChange(int oldPKPoints, int newPKPoints)
+	{
+		if (hasListeners())
+		{
+			for (IPKPointsChangeEventListener listener : getEventListeners(IPKPointsChangeEventListener.class))
+			{
+				try
+				{
+					if (!listener.onPKPointsChange(getActingPlayer(), oldPKPoints, newPKPoints))
+					{
+						return false;
+					}
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
+			}
+		}
+		return true;
+	}
+	
+	/**
+	 * Fired whenever player's pvp points has change.
+	 * @param oldPvPPoints
+	 * @param newPvPPoints
+	 * @return {@code true} if pvp points change is possible, {@code false} otherwise.
+	 */
+	public boolean onPvPChange(int oldPvPPoints, int newPvPPoints)
+	{
+		if (hasListeners())
+		{
+			for (IPvPPointsEventChange listener : getEventListeners(IPvPPointsEventChange.class))
+			{
+				try
+				{
+					if (!listener.onPvPPointsChange(getActingPlayer(), oldPvPPoints, newPvPPoints))
+					{
+						return false;
+					}
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
+			}
+		}
+		return true;
+	}
+	
+	/**
+	 * Fired whenever player's fame points has change.
+	 * @param oldFamePoints
+	 * @param newFamePoints
+	 * @return {@code true} if fame points change is possible, {@code false} otherwise.
+	 */
+	public boolean onFameChange(int oldFamePoints, int newFamePoints)
+	{
+		if (hasListeners())
+		{
+			for (IFamePointsChangeEventListener listener : getEventListeners(IFamePointsChangeEventListener.class))
+			{
+				try
+				{
+					if (!listener.onFamePointsChange(getActingPlayer(), oldFamePoints, newFamePoints))
+					{
+						return false;
+					}
+				}
+				catch (Exception e)
+				{
+					_log.log(Level.WARNING, getClass().getSimpleName() + ": Exception caught: ", e);
+					continue;
+				}
+			}
+		}
+		return true;
+	}
 }

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/events/listeners/IAttackEventListener.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2004-2013 L2J Server
+ * 
+ * This file is part of L2J Server.
+ * 
+ * L2J Server is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * L2J Server is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.gameserver.model.actor.events.listeners;
+
+import com.l2jserver.gameserver.model.actor.L2Character;
+
+/**
+ * @author UnAfraid
+ */
+public interface IAttackEventListener extends IEventListener
+{
+	public boolean onAttack(L2Character attacker, L2Character target);
+}

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/events/listeners/IFamePointsChangeEventListener.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2004-2013 L2J Server
+ * 
+ * This file is part of L2J Server.
+ * 
+ * L2J Server is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * L2J Server is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.gameserver.model.actor.events.listeners;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+ * @author UnAfraid
+ */
+public interface IFamePointsChangeEventListener extends IEventListener
+{
+	public boolean onFamePointsChange(L2PcInstance player, int oldFame, int newFame);
+}

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/events/listeners/IKarmaChangeEventListener.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2004-2013 L2J Server
+ * 
+ * This file is part of L2J Server.
+ * 
+ * L2J Server is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * L2J Server is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.gameserver.model.actor.events.listeners;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+ * @author UnAfraid
+ */
+public interface IKarmaChangeEventListener extends IEventListener
+{
+	public boolean onKarmaChange(L2PcInstance player, int oldKarma, int newKarma);
+}

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/events/listeners/IPKPointsChangeEventListener.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2004-2013 L2J Server
+ * 
+ * This file is part of L2J Server.
+ * 
+ * L2J Server is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * L2J Server is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.gameserver.model.actor.events.listeners;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+ * @author UnAfraid
+ */
+public interface IPKPointsChangeEventListener extends IEventListener
+{
+	public boolean onPKPointsChange(L2PcInstance player, int oldPKPoints, int newPKPoints);
+}

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/events/listeners/IPvPPointsEventChange.java

@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2004-2013 L2J Server
+ * 
+ * This file is part of L2J Server.
+ * 
+ * L2J Server is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * L2J Server is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.gameserver.model.actor.events.listeners;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+ * @author UnAfraid
+ */
+public interface IPvPPointsEventChange extends IEventListener
+{
+	public boolean onPvPPointsChange(L2PcInstance player, int oldPvPPoints, int newPvPPoints);
+}

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/events/listeners/ISkillUseEventListener.java

@@ -0,0 +1,31 @@
+/*
+ * Copyright (C) 2004-2013 L2J Server
+ * 
+ * This file is part of L2J Server.
+ * 
+ * L2J Server is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ * 
+ * L2J Server is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ * General Public License for more details.
+ * 
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.gameserver.model.actor.events.listeners;
+
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.skills.L2Skill;
+
+/**
+ * @author UnAfraid
+ */
+public interface ISkillUseEventListener extends IEventListener
+{
+	public boolean onSkillUse(L2Character caster, L2Skill skill, boolean simultaneously, L2Character target, L2Object[] targets);
+}

L2J_Server_BETA/java/com/l2jserver/gameserver/model/actor/instance/L2PcInstance.java

@@ -2068,6 +2068,11 @@ public final class L2PcInstance extends L2Playable
 	 */
 	public void setPkKills(int pkKills)
 	{
+		if (!getEvents().onPKChange(_pkKills, pkKills))
+		{
+			return;
+		}
+		
 		_pkKills = pkKills;
 	}
 	
@@ -2179,6 +2184,11 @@ public final class L2PcInstance extends L2Playable
 	 */
 	public void setKarma(int karma)
 	{
+		if (!getEvents().onKarmaChange(_karma, karma))
+		{
+			return;
+		}
+		
 		if (karma < 0)
 		{
 			karma = 0;
@@ -2471,6 +2481,10 @@ public final class L2PcInstance extends L2Playable
 	 */
 	public void setPvpKills(int pvpKills)
 	{
+		if (!getEvents().onPvPChange(_pvpKills, pvpKills))
+		{
+			return;
+		}
 		_pvpKills = pvpKills;
 	}
 	
@@ -2488,6 +2502,10 @@ public final class L2PcInstance extends L2Playable
 	 */
 	public void setFame(int fame)
 	{
+		if (!getEvents().onFameChange(_fame, fame))
+		{
+			return;
+		}
 		_fame = (fame > Config.MAX_PERSONAL_FAME_POINTS) ? Config.MAX_PERSONAL_FAME_POINTS : fame;
 	}
 	

L2J_Server_BETA/java/com/l2jserver/gameserver/scripting/scriptengine/events/SkillUseEvent.java

@@ -28,16 +28,17 @@ import com.l2jserver.gameserver.scripting.scriptengine.events.impl.L2Event;
  */
 public class SkillUseEvent implements L2Event
 {
-	private L2Character caster;
-	private L2Skill skill;
-	private L2Object[] targets;
+	private L2Character _caster;
+	private L2Skill _skill;
+	private L2Character _target;
+	private L2Object[] _targets;
 	
 	/**
 	 * @return the caster
 	 */
 	public L2Character getCaster()
 	{
-		return caster;
+		return _caster;
 	}
 	
 	/**
@@ -45,7 +46,7 @@ public class SkillUseEvent implements L2Event
 	 */
 	public void setCaster(L2Character caster)
 	{
-		this.caster = caster;
+		_caster = caster;
 	}
 	
 	/**
@@ -53,7 +54,7 @@ public class SkillUseEvent implements L2Event
 	 */
 	public L2Object[] getTargets()
 	{
-		return targets;
+		return _targets;
 	}
 	
 	/**
@@ -61,7 +62,7 @@ public class SkillUseEvent implements L2Event
 	 */
 	public void setTargets(L2Object[] targets)
 	{
-		this.targets = targets;
+		_targets = targets;
 	}
 	
 	/**
@@ -69,7 +70,7 @@ public class SkillUseEvent implements L2Event
 	 */
 	public L2Skill getSkill()
 	{
-		return skill;
+		return _skill;
 	}
 	
 	/**
@@ -77,6 +78,22 @@ public class SkillUseEvent implements L2Event
 	 */
 	public void setSkill(L2Skill skill)
 	{
-		this.skill = skill;
+		_skill = skill;
+	}
+	
+	/**
+	 * @return Caster's selected target.
+	 */
+	public L2Character getTarget()
+	{
+		return _target;
+	}
+	
+	/**
+	 * @param target
+	 */
+	public void setTarget(L2Character target)
+	{
+		_target = target;
 	}
 }

L2J_Server_BETA/java/com/l2jserver/gameserver/scripting/scriptengine/impl/L2Script.java

@@ -22,9 +22,11 @@ import java.util.ArrayList;
 import java.util.List;
 
 import com.l2jserver.gameserver.model.L2Clan;
+import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.model.quest.Quest;
+import com.l2jserver.gameserver.model.skills.L2Skill;
 import com.l2jserver.gameserver.scripting.scriptengine.events.AddToInventoryEvent;
 import com.l2jserver.gameserver.scripting.scriptengine.events.AttackEvent;
 import com.l2jserver.gameserver.scripting.scriptengine.events.AugmentEvent;
@@ -148,32 +150,12 @@ public abstract class L2Script extends Quest
 		}
 	}
 	
-	/**
-	 * Used locally to call onDeath()
-	 * @param event
-	 * @return
-	 */
-	protected boolean notifyDeath(DeathEvent event)
-	{
-		return onDeath(event);
-	}
-	
-	/**
-	 * Used locally to call onAttack(L2Character,L2Character)
-	 * @param event
-	 * @return
-	 */
-	protected boolean notifyAttack(AttackEvent event)
-	{
-		return onAttack(event);
-	}
-	
 	// Register for event notification
 	/**
 	 * Will notify the script when this L2Character is killed<br>
 	 * Can be used for Npc or Player<br>
 	 * When the L2Character is killed, the onDeath(L2Character,L2Character) method will be fired<br>
-	 * To set a global notifier (for all L2Character) set character to null!
+	 * If you specify null character you will get notified for all deaths from all L2Characters.
 	 * @param character
 	 */
 	public void addDeathNotify(final L2Character character)
@@ -181,15 +163,12 @@ public abstract class L2Script extends Quest
 		DeathListener listener = new DeathListener(character)
 		{
 			@Override
-			public boolean onKill(DeathEvent event)
+			public boolean onDeath(L2Character attacker, L2Character target)
 			{
-				return notifyDeath(event);
-			}
-			
-			@Override
-			public boolean onDeath(DeathEvent event)
-			{
-				return notifyDeath(event);
+				final DeathEvent event = new DeathEvent();
+				event.setKiller(attacker);
+				event.setVictim(target);
+				return L2Script.this.onDeath(event);
 			}
 		};
 		_listeners.add(listener);
@@ -258,29 +237,23 @@ public abstract class L2Script extends Quest
 	}
 	
 	/**
-	 * Adds an L2Character-specific attack listener Fires onAttack(L2Character target, L2Character attacker) when this character is attacked AND when it gets attacked
+	 * Adds an L2Character-specific attack listener Fires onAttack(L2Character target, L2Character attacker) when this character is attacked AND when it gets attacked If you specify null character you will get notified for all attacks from all L2Characters.
 	 * @param character
 	 */
 	public void addAttackNotify(final L2Character character)
 	{
-		if (character != null)
+		AttackListener listener = new AttackListener(character)
 		{
-			AttackListener listener = new AttackListener(character)
+			@Override
+			public boolean onAttack(L2Character attacker, L2Character target)
 			{
-				@Override
-				public boolean onAttack(AttackEvent event)
-				{
-					return notifyAttack(event);
-				}
-				
-				@Override
-				public boolean isAttacked(AttackEvent event)
-				{
-					return notifyAttack(event);
-				}
-			};
-			_listeners.add(listener);
-		}
+				final AttackEvent event = new AttackEvent();
+				event.setAttacker(attacker);
+				event.setTarget(target);
+				return L2Script.this.onAttack(event);
+			}
+		};
+		_listeners.add(listener);
 	}
 	
 	/**
@@ -289,89 +262,50 @@ public abstract class L2Script extends Quest
 	 */
 	public void removeAttackNotify(L2Character character)
 	{
-		if (character != null)
+		List<L2JListener> removeList = new ArrayList<>();
+		for (L2JListener listener : _listeners)
 		{
-			List<L2JListener> removeList = new ArrayList<>();
-			for (L2JListener listener : _listeners)
+			if ((listener instanceof AttackListener) && (((AttackListener) listener).getCharacter() == character))
 			{
-				if ((listener instanceof AttackListener) && (((AttackListener) listener).getCharacter() == character))
-				{
-					removeList.add(listener);
-				}
+				removeList.add(listener);
 			}
-			removeListeners(removeList);
 		}
+		removeListeners(removeList);
 	}
 	
 	/**
-	 * NPC specific, will only be triggered when npc with the given ID uses the correct skill Use skillId = -1 to be notified of all skills used Use npcId = -1 to be notified for all NPCs use npcId = -2 to be notified for all players use npcId = -3 to be notified for all L2Characters
-	 * @param npcId
-	 * @param skillId
+	 * L2Character specific, will only be fired when this L2Character uses any skill.<br>
+	 * If you specify null character you will get notified for all casts from all L2Characters.
+	 * @param character
 	 */
-	public void addSkillUseNotify(int npcId, int skillId)
+	public void addSkillUseNotify(L2Character character)
 	{
-		SkillUseListener listener = new SkillUseListener(npcId, skillId)
+		SkillUseListener listener = new SkillUseListener(character)
 		{
 			@Override
-			public boolean onSkillUse(SkillUseEvent event)
+			public boolean onSkillUse(L2Character caster, L2Skill skill, boolean simultaneously, L2Character target, L2Object[] targets)
 			{
-				return onUseSkill(event);
+				final SkillUseEvent event = new SkillUseEvent();
+				event.setCaster(caster);
+				event.setSkill(skill);
+				event.setTarget(target);
+				event.setTargets(targets);
+				return L2Script.this.onSkillUse(event);
 			}
 		};
 		_listeners.add(listener);
 	}
 	
-	/**
-	 * L2Character specific, will only be fired when this L2Character uses the specified skill Use skillId = -1 to be notified of all skills used
-	 * @param character
-	 * @param skillId
-	 */
-	public void addSkillUseNotify(L2Character character, int skillId)
-	{
-		if (character != null)
-		{
-			SkillUseListener listener = new SkillUseListener(character, skillId)
-			{
-				@Override
-				public boolean onSkillUse(SkillUseEvent event)
-				{
-					return onUseSkill(event);
-				}
-			};
-			_listeners.add(listener);
-		}
-	}
-	
 	/**
 	 * Removes a skill use listener
 	 * @param character
 	 */
 	public void removeSkillUseNotify(L2Character character)
-	{
-		if (character != null)
-		{
-			List<L2JListener> removeList = new ArrayList<>();
-			for (L2JListener listener : _listeners)
-			{
-				if ((listener instanceof SkillUseListener) && (((SkillUseListener) listener).getCharacter() == character))
-				{
-					removeList.add(listener);
-				}
-			}
-			removeListeners(removeList);
-		}
-	}
-	
-	/**
-	 * Removes a skill use listener
-	 * @param npcId
-	 */
-	public void removeSkillUseNotify(int npcId)
 	{
 		List<L2JListener> removeList = new ArrayList<>();
 		for (L2JListener listener : _listeners)
 		{
-			if ((listener instanceof SkillUseListener) && (((SkillUseListener) listener).getNpcId() == npcId))
+			if ((listener instanceof SkillUseListener) && (((SkillUseListener) listener).getCharacter() == character))
 			{
 				removeList.add(listener);
 			}
@@ -1299,12 +1233,12 @@ public abstract class L2Script extends Quest
 	}
 	
 	/**
-	 * Fired when a SKillUseListener gets triggered.<br>
+	 * Fired when a SkillUseListener gets triggered.<br>
 	 * Register using addSkillUseNotify()
 	 * @param event
 	 * @return
 	 */
-	public boolean onUseSkill(SkillUseEvent event)
+	public boolean onSkillUse(SkillUseEvent event)
 	{
 		return true;
 	}

L2J_Server_BETA/java/com/l2jserver/gameserver/scripting/scriptengine/listeners/character/AttackListener.java

@@ -19,13 +19,14 @@
 package com.l2jserver.gameserver.scripting.scriptengine.listeners.character;
 
 import com.l2jserver.gameserver.model.actor.L2Character;
-import com.l2jserver.gameserver.scripting.scriptengine.events.AttackEvent;
+import com.l2jserver.gameserver.model.actor.events.AbstractCharEvents;
+import com.l2jserver.gameserver.model.actor.events.listeners.IAttackEventListener;
 import com.l2jserver.gameserver.scripting.scriptengine.impl.L2JListener;
 
 /**
  * @author TheOne
  */
-public abstract class AttackListener extends L2JListener
+public abstract class AttackListener extends L2JListener implements IAttackEventListener
 {
 	private L2Character _character = null;
 	
@@ -41,30 +42,30 @@ public abstract class AttackListener extends L2JListener
 		register();
 	}
 	
-	/**
-	 * The player just attacked another character
-	 * @param event
-	 * @return
-	 */
-	public abstract boolean onAttack(AttackEvent event);
-	
-	/**
-	 * The player was just attacked by another character
-	 * @param event
-	 * @return
-	 */
-	public abstract boolean isAttacked(AttackEvent event);
-	
 	@Override
 	public void register()
 	{
-		_character.addAttackListener(this);
+		if (_character == null)
+		{
+			AbstractCharEvents.registerStaticListener(this);
+		}
+		else
+		{
+			_character.getEvents().registerListener(this);
+		}
 	}
 	
 	@Override
 	public void unregister()
 	{
-		_character.removeAttackListener(this);
+		if (_character == null)
+		{
+			AbstractCharEvents.unregisterStaticListener(this);
+		}
+		else
+		{
+			_character.getEvents().unregisterListener(this);
+		}
 	}
 	
 	/**

L2J_Server_BETA/java/com/l2jserver/gameserver/scripting/scriptengine/listeners/character/DeathListener.java

@@ -19,7 +19,8 @@
 package com.l2jserver.gameserver.scripting.scriptengine.listeners.character;
 
 import com.l2jserver.gameserver.model.actor.L2Character;
-import com.l2jserver.gameserver.scripting.scriptengine.events.DeathEvent;
+import com.l2jserver.gameserver.model.actor.events.AbstractCharEvents;
+import com.l2jserver.gameserver.model.actor.events.listeners.IDeathEventListener;
 import com.l2jserver.gameserver.scripting.scriptengine.impl.L2JListener;
 
 /**
@@ -27,10 +28,9 @@ import com.l2jserver.gameserver.scripting.scriptengine.impl.L2JListener;
  * Works for NPCs and Players
  * @author TheOne
  */
-public abstract class DeathListener extends L2JListener
+public abstract class DeathListener extends L2JListener implements IDeathEventListener
 {
 	private L2Character _character = null;
-	private boolean _isGlobal = false;
 	
 	/**
 	 * constructor To have a global listener, set character to null
@@ -38,30 +38,10 @@ public abstract class DeathListener extends L2JListener
 	 */
 	public DeathListener(L2Character character)
 	{
-		if (character == null)
-		{
-			_isGlobal = true;
-		}
 		_character = character;
 		register();
 	}
 	
-	/**
-	 * The character just killed the target<br>
-	 * If you use this listener as global, use: onDeathGlobal()
-	 * @param event
-	 * @return
-	 */
-	public abstract boolean onKill(DeathEvent event);
-	
-	/**
-	 * The character was just killed by the target<br>
-	 * If you use this listener as global, use: onDeathGlobal()
-	 * @param event
-	 * @return
-	 */
-	public abstract boolean onDeath(DeathEvent event);
-	
 	/**
 	 * Returns the character
 	 * @return
@@ -74,26 +54,26 @@ public abstract class DeathListener extends L2JListener
 	@Override
 	public void register()
 	{
-		if (_isGlobal)
+		if (_character == null)
 		{
-			L2Character.addGlobalDeathListener(this);
+			AbstractCharEvents.registerStaticListener(this);
 		}
 		else
 		{
-			_character.addDeathListener(this);
+			_character.getEvents().registerListener(this);
 		}
 	}
 	
 	@Override
 	public void unregister()
 	{
-		if (_isGlobal)
+		if (_character == null)
 		{
-			L2Character.removeGlobalDeathListener(this);
+			AbstractCharEvents.unregisterStaticListener(this);
 		}
 		else
 		{
-			_character.removeDeathListener(this);
+			_character.getEvents().unregisterListener(this);
 		}
 	}
 }

L2J_Server_BETA/java/com/l2jserver/gameserver/scripting/scriptengine/listeners/character/SkillUseListener.java

@@ -19,95 +19,53 @@
 package com.l2jserver.gameserver.scripting.scriptengine.listeners.character;
 
 import com.l2jserver.gameserver.model.actor.L2Character;
-import com.l2jserver.gameserver.scripting.scriptengine.events.SkillUseEvent;
+import com.l2jserver.gameserver.model.actor.events.AbstractCharEvents;
+import com.l2jserver.gameserver.model.actor.events.listeners.ISkillUseEventListener;
 import com.l2jserver.gameserver.scripting.scriptengine.impl.L2JListener;
 
 /**
  * @author TheOne
  */
-public abstract class SkillUseListener extends L2JListener
+public abstract class SkillUseListener extends L2JListener implements ISkillUseEventListener
 {
 	private L2Character _character = null;
-	private int _skillId = -1;
-	private int _npcId = -1;
-	private boolean _characterSpecific = false;
 	
 	/**
 	 * constructor L2Character specific, will only be fired when this L2Character uses the specified skill Use skillId = -1 to be notified of all skills used
 	 * @param character
-	 * @param skillId
 	 */
-	public SkillUseListener(L2Character character, int skillId)
+	public SkillUseListener(L2Character character)
 	{
-		_skillId = skillId;
 		_character = character;
-		_characterSpecific = true;
 		register();
 	}
 	
-	/**
-	 * constructor NPC specific, will only be triggered when npc with the given ID uses the correct skill Use skillId = -1 to be notified of all skills used Use npcId = -1 to be notified for all NPCs use npcId = -2 to be notified for all players use npcId = -3 to be notified for all L2Characters
-	 * @param npcId
-	 * @param skillId
-	 */
-	public SkillUseListener(int npcId, int skillId)
-	{
-		_skillId = skillId;
-		_npcId = npcId;
-		register();
-	}
-	
-	/**
-	 * A L2Character just cast a skill
-	 * @param event
-	 * @return
-	 */
-	public abstract boolean onSkillUse(SkillUseEvent event);
-	
 	@Override
 	public void register()
 	{
-		if (!_characterSpecific)
+		if (_character == null)
 		{
-			L2Character.addGlobalSkillUseListener(this);
+			AbstractCharEvents.registerStaticListener(this);
 		}
 		else
 		{
-			_character.addSkillUseListener(this);
+			_character.getEvents().registerListener(this);
 		}
 	}
 	
 	@Override
 	public void unregister()
 	{
-		if (!_characterSpecific)
+		if (_character == null)
 		{
-			L2Character.removeGlobalSkillUseListener(this);
+			AbstractCharEvents.unregisterStaticListener(this);
 		}
 		else
 		{
-			_character.removeSkillUseListener(this);
+			_character.getEvents().unregisterListener(this);
 		}
 	}
 	
-	/**
-	 * Returns the npcId this listener will be triggered for
-	 * @return
-	 */
-	public int getNpcId()
-	{
-		return _npcId;
-	}
-	
-	/**
-	 * Returns the skillId this listener will be triggered for
-	 * @return
-	 */
-	public int getSkillId()
-	{
-		return _skillId;
-	}
-	
 	/**
 	 * Returns the L2Character this listener is attached to
 	 * @return