BETA: DP-Part of [L4934]

L2J_DataPack_BETA/data/scripts/handlers/TargetMasterHandler.java

@@ -0,0 +1,96 @@
+/**
+ * 
+ */
+package handlers;
+
+import handlers.targethandlers.TargetAlly;
+import handlers.targethandlers.TargetArea;
+import handlers.targethandlers.TargetAreaCorpseMob;
+import handlers.targethandlers.TargetAreaSummon;
+import handlers.targethandlers.TargetAreaUndead;
+import handlers.targethandlers.TargetAura;
+import handlers.targethandlers.TargetAuraCorpseMob;
+import handlers.targethandlers.TargetBehindArea;
+import handlers.targethandlers.TargetBehindAura;
+import handlers.targethandlers.TargetClan;
+import handlers.targethandlers.TargetClanMember;
+import handlers.targethandlers.TargetCorpseAlly;
+import handlers.targethandlers.TargetCorpseClan;
+import handlers.targethandlers.TargetCorpseMob;
+import handlers.targethandlers.TargetCorpsePet;
+import handlers.targethandlers.TargetCorpsePlayer;
+import handlers.targethandlers.TargetEnemySummon;
+import handlers.targethandlers.TargetFlagPole;
+import handlers.targethandlers.TargetFrontArea;
+import handlers.targethandlers.TargetFrontAura;
+import handlers.targethandlers.TargetGround;
+import handlers.targethandlers.TargetHoly;
+import handlers.targethandlers.TargetOne;
+import handlers.targethandlers.TargetOwnerPet;
+import handlers.targethandlers.TargetParty;
+import handlers.targethandlers.TargetPartyClan;
+import handlers.targethandlers.TargetPartyMember;
+import handlers.targethandlers.TargetPartyNotMe;
+import handlers.targethandlers.TargetPartyOther;
+import handlers.targethandlers.TargetPet;
+import handlers.targethandlers.TargetSelf;
+import handlers.targethandlers.TargetSummon;
+import handlers.targethandlers.TargetUndead;
+import handlers.targethandlers.TargetUnlockable;
+
+import java.util.logging.Logger;
+
+import com.l2jserver.gameserver.handler.TargetHandler;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetMasterHandler
+{
+	private static Logger _log = Logger.getLogger(TargetMasterHandler.class.getName());
+	
+	public static void loadTargetHandlers()
+	{
+		TargetHandler.getInstance().registerSkillTargetType(new TargetAlly());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetArea());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetAreaCorpseMob());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetAreaSummon());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetAreaUndead());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetAura());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetAuraCorpseMob());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetBehindArea());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetBehindAura());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetClan());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetClanMember());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetCorpseAlly());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetCorpseClan());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetCorpseMob());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetCorpsePet());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetCorpsePlayer());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetEnemySummon());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetFlagPole());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetFrontArea());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetFrontAura());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetGround());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetHoly());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetOne());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetOwnerPet());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetParty());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetPartyClan());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetPartyMember());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetPartyNotMe());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetPartyOther());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetPet());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetSelf());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetSummon());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetUndead());
+		TargetHandler.getInstance().registerSkillTargetType(new TargetUnlockable());
+	}
+	
+	public static void main(String[] args)
+	{
+		loadTargetHandlers();
+		_log.config("Loaded " + TargetHandler.getInstance().size() + " Target handlers");
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetAlly.java

@@ -0,0 +1,102 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.entity.TvTEvent;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetAlly implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (activeChar instanceof L2Playable)
+		{
+			final L2PcInstance player = activeChar.getActingPlayer();
+			
+			if (player == null)
+				return _emptyTargetList;
+			
+			if (player.isInOlympiadMode())
+				return new L2Character[] { player };
+			
+			if (onlyFirst)
+				return new L2Character[] { player };
+			
+			targetList.add(player);
+			
+			final int radius = skill.getSkillRadius();
+			
+			if (L2Skill.addSummon(activeChar, player, radius, false))
+				targetList.add(player.getPet());
+			
+			if (player.getClan() != null)
+			{
+				// Get all visible objects in a spherical area near the L2Character
+				final Collection<L2PcInstance> objs = activeChar.getKnownList().getKnownPlayersInRadius(radius);
+				for (L2PcInstance obj : objs)
+				{
+					if (obj == null)
+						continue;
+					if ((obj.getAllyId() == 0 || obj.getAllyId() != player.getAllyId()) && (obj.getClan() == null || obj.getClanId() != player.getClanId()))
+						continue;
+					
+					if (player.isInDuel())
+					{
+						if (player.getDuelId() != obj.getDuelId())
+							continue;
+						if (player.isInParty() && obj.isInParty() && player.getParty().getPartyLeaderOID() != obj.getParty().getPartyLeaderOID())
+							continue;
+					}
+					
+					// Don't add this target if this is a Pc->Pc pvp
+					// casting and pvp condition not met
+					if (!player.checkPvpSkill(obj, skill))
+						continue;
+					
+					if (!TvTEvent.checkForTvTSkill(player, obj, skill))
+						continue;
+					
+					if (!onlyFirst && L2Skill.addSummon(activeChar, obj, radius, false))
+						targetList.add(obj.getPet());
+					
+					if (!L2Skill.addCharacter(activeChar, obj, radius, false))
+						continue;
+					
+					if (onlyFirst)
+						return new L2Character[] { obj };
+					
+					if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+						break;
+					
+					targetList.add(obj);
+				}
+			}
+		}
+		
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_ALLY;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetArea.java

@@ -0,0 +1,88 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+import com.l2jserver.gameserver.util.Util;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetArea implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (((target == null || target == activeChar || target.isAlikeDead()) && skill.getCastRange() >= 0) || (!(target instanceof L2Attackable || target instanceof L2Playable)))
+		{
+			activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+			return _emptyTargetList;
+		}
+		
+		final L2Character origin;
+		final boolean srcInArena = (activeChar.isInsideZone(L2Character.ZONE_PVP) && !activeChar.isInsideZone(L2Character.ZONE_SIEGE));
+		final int radius = skill.getSkillRadius();
+		
+		if (skill.getCastRange() >= 0)
+		{
+			if (!L2Skill.checkForAreaOffensiveSkills(activeChar, target, skill, srcInArena))
+				return _emptyTargetList;
+			
+			if (onlyFirst)
+				return new L2Character[] { target };
+			
+			origin = target;
+			targetList.add(origin); // Add target to target list
+		}
+		else
+			origin = activeChar;
+		
+		final Collection<L2Character> objs = activeChar.getKnownList().getKnownCharacters();
+		for (L2Character obj : objs)
+		{
+			if (!(obj instanceof L2Attackable || obj instanceof L2Playable))
+				continue;
+			
+			if (obj == origin)
+				continue;
+			
+			if (Util.checkIfInRange(radius, origin, obj, true))
+			{
+				if (!L2Skill.checkForAreaOffensiveSkills(activeChar, obj, skill, srcInArena))
+					continue;
+				
+				if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+					break;
+				
+				targetList.add(obj);
+			}
+		}
+		
+		if (targetList.isEmpty())
+			return _emptyTargetList;
+		
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_AREA;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetAreaCorpseMob.java

@@ -0,0 +1,68 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+import com.l2jserver.gameserver.util.Util;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetAreaCorpseMob implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if ((!(target instanceof L2Attackable)) || !target.isDead())
+		{
+			activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+			return _emptyTargetList;
+		}
+		
+		if (onlyFirst)
+			return new L2Character[] { target };
+		
+		targetList.add(target);
+		
+		final boolean srcInArena = (activeChar.isInsideZone(L2Character.ZONE_PVP) && !activeChar.isInsideZone(L2Character.ZONE_SIEGE));
+		
+		final int radius = skill.getSkillRadius();
+		final Collection<L2Character> objs = activeChar.getKnownList().getKnownCharacters();
+		for (L2Character obj : objs)
+		{
+			if (!(obj instanceof L2Attackable || obj instanceof L2Playable) || !Util.checkIfInRange(radius, target, obj, true))
+				continue;
+			
+			if (!L2Skill.checkForAreaOffensiveSkills(activeChar, obj, skill, srcInArena))
+				continue;
+			
+			targetList.add(obj);
+		}
+		
+		if (targetList.isEmpty())
+			return _emptyTargetList;
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_AREA_CORPSE_MOB;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetAreaSummon.java

@@ -0,0 +1,73 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.model.actor.instance.L2SummonInstance;
+import com.l2jserver.gameserver.util.Util;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetAreaSummon implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		target = activeChar.getPet();
+		if (target == null || !(target instanceof L2SummonInstance) || target.isDead())
+			return _emptyTargetList;
+		
+		if (onlyFirst)
+			return new L2Character[] { target };
+		
+		final boolean srcInArena = (activeChar.isInsideZone(L2Character.ZONE_PVP) && !activeChar.isInsideZone(L2Character.ZONE_SIEGE));
+		final Collection<L2Character> objs = target.getKnownList().getKnownCharacters();
+		final int radius = skill.getSkillRadius();
+		
+		for (L2Character obj : objs)
+		{
+			if (obj == null || obj == target || obj == activeChar)
+				continue;
+			
+			if (!Util.checkIfInRange(radius, target, obj, true))
+				continue;
+			
+			if (!(obj instanceof L2Attackable || obj instanceof L2Playable))
+				continue;
+			
+			if (!L2Skill.checkForAreaOffensiveSkills(activeChar, obj, skill, srcInArena))
+				continue;
+			
+			if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+				break;
+			
+			targetList.add(obj);
+		}
+		
+		if (targetList.isEmpty())
+			return _emptyTargetList;
+		
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_AREA_SUMMON;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetAreaUndead.java

@@ -0,0 +1,83 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.Config;
+import com.l2jserver.gameserver.GeoData;
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.model.actor.instance.L2SummonInstance;
+import com.l2jserver.gameserver.util.Util;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetAreaUndead implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		final L2Character cha;
+		final int radius = skill.getSkillRadius();
+		if (skill.getCastRange() >= 0 && (target instanceof L2Npc || target instanceof L2SummonInstance) && target.isUndead() && !target.isAlikeDead())
+		{
+			cha = target;
+			
+			if (!onlyFirst)
+				targetList.add(cha);
+			else
+				return new L2Character[] { cha };
+		}
+		else
+			cha = activeChar;
+		
+		final Collection<L2Character> objs = activeChar.getKnownList().getKnownCharacters();
+		for (L2Character obj : objs)
+		{
+			if (!Util.checkIfInRange(radius, cha, obj, true))
+				continue;
+			else if (obj instanceof L2Npc)
+				target = obj;
+			else if (obj instanceof L2SummonInstance)
+				target = obj;
+			else
+				continue;
+			
+			if (!target.isAlikeDead())
+			{
+				if (!target.isUndead())
+					continue;
+				else if (Config.GEODATA > 0 && !GeoData.getInstance().canSeeTarget(activeChar, target))
+					continue;
+				else if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+					break;
+				else if (!onlyFirst)
+					targetList.add(obj);
+				else
+					return new L2Character[] { obj };
+			}
+		}
+		
+		if (targetList.isEmpty())
+			return _emptyTargetList;
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_AREA_UNDEAD;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetAura.java

@@ -0,0 +1,81 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.templates.skills.L2SkillType;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetAura implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		final boolean srcInArena = (activeChar.isInsideZone(L2Character.ZONE_PVP) && !activeChar.isInsideZone(L2Character.ZONE_SIEGE));
+		
+		final L2PcInstance sourcePlayer = activeChar.getActingPlayer();
+		
+		final Collection<L2Character> objs = activeChar.getKnownList().getKnownCharactersInRadius(skill.getSkillRadius());
+		
+		if (skill.getSkillType() == L2SkillType.DUMMY)
+		{
+			if (onlyFirst)
+				return new L2Character[] { activeChar };
+			
+			targetList.add(activeChar);
+			for (L2Character obj : objs)
+			{
+				if (!(obj == activeChar || obj == sourcePlayer || obj instanceof L2Npc || obj instanceof L2Attackable))
+					continue;
+				
+				if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+					break;
+				
+				targetList.add(obj);
+			}
+		}
+		else
+		{
+			for (L2Character obj : objs)
+			{
+				if (obj instanceof L2Attackable || obj instanceof L2Playable)
+				{
+					if (!L2Skill.checkForAreaOffensiveSkills(activeChar, obj, skill, srcInArena))
+						continue;
+					
+					if (onlyFirst)
+						return new L2Character[] { obj };
+					
+					if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+						break;
+					targetList.add(obj);
+				}
+			}
+		}
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_AURA;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetAuraCorpseMob.java

@@ -0,0 +1,51 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetAuraCorpseMob implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		// Go through the L2Character _knownList
+		final Collection<L2Character> objs = activeChar.getKnownList().getKnownCharactersInRadius(skill.getSkillRadius());
+		for (L2Character obj : objs)
+		{
+			if (obj instanceof L2Attackable && obj.isDead())
+			{
+				if (onlyFirst)
+					return new L2Character[] { obj };
+				
+				if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+					break;
+				
+				targetList.add(obj);
+			}
+		}
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_AURA_CORPSE_MOB;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetBehindArea.java

@@ -0,0 +1,91 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+import com.l2jserver.gameserver.util.Util;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetBehindArea implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (((target == null || target == activeChar || target.isAlikeDead()) && skill.getCastRange() >= 0) || (!(target instanceof L2Attackable || target instanceof L2Playable)))
+		{
+			activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+			return _emptyTargetList;
+		}
+		
+		final L2Character origin;
+		final boolean srcInArena = (activeChar.isInsideZone(L2Character.ZONE_PVP) && !activeChar.isInsideZone(L2Character.ZONE_SIEGE));
+		final int radius = skill.getSkillRadius();
+		
+		if (skill.getCastRange() >= 0)
+		{
+			if (!L2Skill.checkForAreaOffensiveSkills(activeChar, target, skill, srcInArena))
+				return _emptyTargetList;
+			
+			if (onlyFirst)
+				return new L2Character[] { target };
+			
+			origin = target;
+			targetList.add(origin); // Add target to target list
+		}
+		else
+			origin = activeChar;
+		
+		final Collection<L2Character> objs = activeChar.getKnownList().getKnownCharacters();
+		for (L2Character obj : objs)
+		{
+			if (!(obj instanceof L2Attackable || obj instanceof L2Playable))
+				continue;
+			
+			if (obj == origin)
+				continue;
+			
+			if (Util.checkIfInRange(radius, origin, obj, true))
+			{
+				if (!obj.isBehind(activeChar))
+					continue;
+				
+				if (!L2Skill.checkForAreaOffensiveSkills(activeChar, obj, skill, srcInArena))
+					continue;
+				
+				if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+					break;
+				
+				targetList.add(obj);
+			}
+		}
+		
+		if (targetList.isEmpty())
+			return _emptyTargetList;
+		
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_BEHIND_AREA;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetBehindAura.java

@@ -0,0 +1,84 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.templates.skills.L2SkillType;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetBehindAura implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		final boolean srcInArena = (activeChar.isInsideZone(L2Character.ZONE_PVP) && !activeChar.isInsideZone(L2Character.ZONE_SIEGE));
+		
+		final L2PcInstance sourcePlayer = activeChar.getActingPlayer();
+		
+		final Collection<L2Character> objs = activeChar.getKnownList().getKnownCharactersInRadius(skill.getSkillRadius());
+		
+		if (skill.getSkillType() == L2SkillType.DUMMY)
+		{
+			if (onlyFirst)
+				return new L2Character[] { activeChar };
+			
+			targetList.add(activeChar);
+			for (L2Character obj : objs)
+			{
+				if (!(obj == activeChar || obj == sourcePlayer || obj instanceof L2Npc || obj instanceof L2Attackable))
+					continue;
+				
+				if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+					break;
+				targetList.add(obj);
+			}
+		}
+		else
+		{
+			for (L2Character obj : objs)
+			{
+				if (obj instanceof L2Attackable || obj instanceof L2Playable)
+				{
+					
+					if (!obj.isBehind(activeChar))
+						continue;
+					
+					if (!L2Skill.checkForAreaOffensiveSkills(activeChar, obj, skill, srcInArena))
+						continue;
+					
+					if (onlyFirst)
+						return new L2Character[] { obj };
+					
+					if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+						break;
+					targetList.add(obj);
+				}
+			}
+		}
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_BEHIND_AURA;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetClan.java

@@ -0,0 +1,132 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Clan;
+import com.l2jserver.gameserver.model.L2ClanMember;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.entity.TvTEvent;
+import com.l2jserver.gameserver.util.Util;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetClan implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (activeChar instanceof L2Playable)
+		{
+			final L2PcInstance player = activeChar.getActingPlayer();
+			
+			if (player == null)
+				return _emptyTargetList;
+			
+			if (player.isInOlympiadMode())
+				return new L2Character[] { player };
+			
+			if (onlyFirst)
+				return new L2Character[] { player };
+			
+			targetList.add(player);
+			
+			final int radius = skill.getSkillRadius();
+			final L2Clan clan = player.getClan();
+			
+			if (L2Skill.addSummon(activeChar, player, radius, false))
+				targetList.add(player.getPet());
+			
+			if (clan != null)
+			{
+				L2PcInstance obj;
+				for (L2ClanMember member : clan.getMembers())
+				{
+					obj = member.getPlayerInstance();
+					
+					if (obj == null || obj == player)
+						continue;
+					
+					if (player.isInDuel())
+					{
+						if (player.getDuelId() != obj.getDuelId())
+							continue;
+						if (player.isInParty() && obj.isInParty() && player.getParty().getPartyLeaderOID() != obj.getParty().getPartyLeaderOID())
+							continue;
+					}
+					
+					// Don't add this target if this is a Pc->Pc pvp casting and pvp condition not met
+					if (!player.checkPvpSkill(obj, skill))
+						continue;
+					
+					if (!TvTEvent.checkForTvTSkill(player, obj, skill))
+						continue;
+					
+					if (!onlyFirst && L2Skill.addSummon(activeChar, obj, radius, false))
+						targetList.add(obj.getPet());
+					
+					if (!L2Skill.addCharacter(activeChar, obj, radius, false))
+						continue;
+					
+					if (onlyFirst)
+						return new L2Character[] { obj };
+					
+					if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+						break;
+					
+					targetList.add(obj);
+				}
+			}
+		}
+		else if (activeChar instanceof L2Npc)
+		{
+			// for buff purposes, returns friendly mobs nearby and mob itself
+			final L2Npc npc = (L2Npc) activeChar;
+			if (npc.getFactionId() == null || npc.getFactionId().isEmpty())
+			{
+				return new L2Character[] { activeChar };
+			}
+			
+			targetList.add(activeChar);
+			
+			final Collection<L2Object> objs = activeChar.getKnownList().getKnownObjects().values();
+			
+			for (L2Object newTarget : objs)
+			{
+				if (newTarget instanceof L2Npc && npc.getFactionId().equals(((L2Npc) newTarget).getFactionId()))
+				{
+					if (!Util.checkIfInRange(skill.getCastRange(), activeChar, newTarget, true))
+						continue;
+					
+					if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+						break;
+					
+					targetList.add((L2Npc) newTarget);
+				}
+			}
+		}
+		
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_CLAN;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetClanMember.java

@@ -0,0 +1,63 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.util.Util;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetClanMember implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (activeChar instanceof L2Npc)
+		{
+			// for buff purposes, returns friendly mobs nearby and mob itself
+			final L2Npc npc = (L2Npc) activeChar;
+			if (npc.getFactionId() == null || npc.getFactionId().isEmpty())
+			{
+				return new L2Character[] { activeChar };
+			}
+			final Collection<L2Object> objs = activeChar.getKnownList().getKnownObjects().values();
+			for (L2Object newTarget : objs)
+			{
+				if (newTarget instanceof L2Npc && npc.getFactionId().equals(((L2Npc) newTarget).getFactionId()))
+				{
+					if (!Util.checkIfInRange(skill.getCastRange(), activeChar, newTarget, true))
+						continue;
+					if (((L2Npc) newTarget).getFirstEffect(skill) != null)
+						continue;
+					targetList.add((L2Npc) newTarget);
+					break;
+				}
+			}
+			if (targetList.isEmpty())
+				targetList.add(npc);
+		}
+		else
+			return _emptyTargetList;
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_CLAN_MEMBER;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetCorpseAlly.java

@@ -0,0 +1,108 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.entity.TvTEvent;
+import com.l2jserver.gameserver.templates.skills.L2SkillType;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetCorpseAlly implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (activeChar instanceof L2Playable)
+		{
+			final L2PcInstance player = activeChar.getActingPlayer();
+			
+			if (player == null)
+				return _emptyTargetList;
+			
+			if (player.isInOlympiadMode())
+				return new L2Character[] {player};
+			
+			final int radius = skill.getSkillRadius();
+			
+			if (L2Skill.addSummon(activeChar, player, radius, true))
+				targetList.add(player.getPet());
+			
+			if (player.getClan() != null)
+			{
+				// Get all visible objects in a spherical area near the L2Character
+				final Collection<L2PcInstance> objs = activeChar.getKnownList().getKnownPlayersInRadius(radius);
+				//synchronized (activeChar.getKnownList().getKnownObjects())
+				{
+					for (L2PcInstance obj : objs)
+					{
+						if (obj == null)
+							continue;
+						if ((obj.getAllyId() == 0 || obj.getAllyId() != player.getAllyId())
+								&& (obj.getClan() == null || obj.getClanId() != player.getClanId()))
+							continue;
+						
+						if (player.isInDuel())
+						{
+							if (player.getDuelId() != obj.getDuelId())
+								continue;
+							if (player.isInParty() && obj.isInParty() && player.getParty().getPartyLeaderOID() != obj.getParty().getPartyLeaderOID())
+								continue;
+						}
+						
+						// Don't add this target if this is a Pc->Pc pvp
+						// casting and pvp condition not met
+						if (!player.checkPvpSkill(obj, skill))
+							continue;
+						
+						if (!TvTEvent.checkForTvTSkill(player, obj, skill))
+							continue;
+						
+						if (!onlyFirst && L2Skill.addSummon(activeChar, obj, radius, true))
+							targetList.add(obj.getPet());
+						
+						if (!L2Skill.addCharacter(activeChar, obj, radius, true))
+							continue;
+						
+						// Siege battlefield resurrect has been made possible for participants
+						if (skill.getSkillType() == L2SkillType.RESURRECT)
+						{
+							if (obj.isInsideZone(L2Character.ZONE_SIEGE) && !obj.isInSiege())
+								continue;
+						}
+						
+						if (onlyFirst)
+							return new L2Character[] { obj };
+						
+						if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+							break;
+						
+						targetList.add(obj);
+					}
+				}
+			}
+		}
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_CORPSE_ALLY;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetCorpseClan.java

@@ -0,0 +1,135 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Clan;
+import com.l2jserver.gameserver.model.L2ClanMember;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.entity.TvTEvent;
+import com.l2jserver.gameserver.templates.skills.L2SkillType;
+import com.l2jserver.gameserver.util.Util;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetCorpseClan implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (activeChar instanceof L2Playable)
+		{
+			final L2PcInstance player = activeChar.getActingPlayer();
+			
+			if (player == null)
+				return _emptyTargetList;
+			
+			if (player.isInOlympiadMode())
+				return new L2Character[] { player };
+			
+			final int radius = skill.getSkillRadius();
+			final L2Clan clan = player.getClan();
+			
+			if (L2Skill.addSummon(activeChar, player, radius, true))
+				targetList.add(player.getPet());
+			
+			if (clan != null)
+			{
+				L2PcInstance obj;
+				for (L2ClanMember member : clan.getMembers())
+				{
+					obj = member.getPlayerInstance();
+					
+					if (obj == null || obj == player)
+						continue;
+					
+					if (player.isInDuel())
+					{
+						if (player.getDuelId() != obj.getDuelId())
+							continue;
+						if (player.isInParty() && obj.isInParty() && player.getParty().getPartyLeaderOID() != obj.getParty().getPartyLeaderOID())
+							continue;
+					}
+					
+					// Don't add this target if this is a Pc->Pc pvp casting and pvp condition not met
+					if (!player.checkPvpSkill(obj, skill))
+						continue;
+					
+					if (!TvTEvent.checkForTvTSkill(player, obj, skill))
+						continue;
+					
+					if (!onlyFirst && L2Skill.addSummon(activeChar, obj, radius, true))
+						targetList.add(obj.getPet());
+					
+					if (!L2Skill.addCharacter(activeChar, obj, radius, true))
+						continue;
+					
+					if (skill.getSkillType() == L2SkillType.RESURRECT)
+					{
+						// check target is not in a active siege zone
+						if (obj.isInsideZone(L2Character.ZONE_SIEGE) && !obj.isInSiege())
+							continue;
+					}
+					
+					if (onlyFirst)
+						return new L2Character[] { obj };
+					
+					if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+						break;
+					
+					targetList.add(obj);
+				}
+			}
+		}
+		else if (activeChar instanceof L2Npc)
+		{
+			// for buff purposes, returns friendly mobs nearby and mob itself
+			final L2Npc npc = (L2Npc) activeChar;
+			if (npc.getFactionId() == null || npc.getFactionId().isEmpty())
+			{
+				return new L2Character[] { activeChar };
+			}
+			
+			targetList.add(activeChar);
+			
+			final Collection<L2Object> objs = activeChar.getKnownList().getKnownObjects().values();
+			
+			for (L2Object newTarget : objs)
+			{
+				if (newTarget instanceof L2Npc && npc.getFactionId().equals(((L2Npc) newTarget).getFactionId()))
+				{
+					if (!Util.checkIfInRange(skill.getCastRange(), activeChar, newTarget, true))
+						continue;
+					
+					if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+						break;
+					
+					targetList.add((L2Npc) newTarget);
+				}
+			}
+		}
+		
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_CORPSE_CLAN;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetCorpseMob.java

@@ -0,0 +1,69 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.Config;
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.instance.L2SummonInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetCorpseMob implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		final boolean isSummon = target instanceof L2SummonInstance;
+		if (!(isSummon || target instanceof L2Attackable) || !target.isDead())
+		{
+			activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+			return _emptyTargetList;
+		}
+		
+		// Corpse mob only available for half time
+		switch (skill.getSkillType())
+		{
+			case SUMMON:
+			{
+				if (isSummon && ((L2SummonInstance)target).getOwner() != null
+						&& ((L2SummonInstance)target).getOwner().getObjectId() == activeChar.getObjectId())
+					return _emptyTargetList;
+			}
+			case DRAIN:
+			{
+				if (((L2Attackable) target).checkCorpseTime(activeChar.getActingPlayer(), (Config.NPC_DECAY_TIME / 2), true))
+				{
+					return _emptyTargetList;
+				}
+			}
+		}
+		
+		if (!onlyFirst)
+		{
+			targetList.add(target);
+			return targetList.toArray(new L2Object[targetList.size()]);
+		}
+		return new L2Character[] { target };
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_CORPSE_MOB;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetCorpsePet.java

@@ -0,0 +1,37 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetCorpsePet implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		if (activeChar instanceof L2PcInstance)
+		{
+			target = activeChar.getPet();
+			if (target != null && target.isDead())
+				return new L2Character[] { target };
+		}
+		
+		return _emptyTargetList;
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_CORPSE_PET;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetCorpsePlayer.java

@@ -0,0 +1,117 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.actor.instance.L2PetInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+import com.l2jserver.gameserver.templates.skills.L2SkillType;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetCorpsePlayer implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (target != null && target.isDead())
+		{
+			final L2PcInstance player;
+			if (activeChar instanceof L2PcInstance)
+				player = (L2PcInstance) activeChar;
+			else
+				player = null;
+			
+			final L2PcInstance targetPlayer;
+			if (target instanceof L2PcInstance)
+				targetPlayer = (L2PcInstance) target;
+			else
+				targetPlayer = null;
+			
+			final L2PetInstance targetPet;
+			if (target instanceof L2PetInstance)
+				targetPet = (L2PetInstance) target;
+			else
+				targetPet = null;
+			
+			if (player != null && (targetPlayer != null || targetPet != null))
+			{
+				boolean condGood = true;
+				
+				if (skill.getSkillType() == L2SkillType.RESURRECT)
+				{
+					if (targetPlayer != null)
+					{
+						// check target is not in a active siege zone
+						if (targetPlayer.isInsideZone(L2Character.ZONE_SIEGE) && !targetPlayer.isInSiege())
+						{
+							condGood = false;
+							activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CANNOT_BE_RESURRECTED_DURING_SIEGE));
+						}
+						
+						if (targetPlayer.isFestivalParticipant()) // Check to see if the current player target is in a festival.
+						{
+							condGood = false;
+							activeChar.sendMessage("You may not resurrect participants in a festival.");
+						}
+						if (targetPlayer.isReviveRequested())
+						{
+							if (targetPlayer.isRevivingPet())
+								player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.MASTER_CANNOT_RES)); // While a pet is attempting to resurrect, it cannot help in resurrecting its master.
+							else
+								player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.RES_HAS_ALREADY_BEEN_PROPOSED)); // Resurrection is already been proposed.
+							condGood = false;
+						}
+					}
+					else if (targetPet != null)
+					{
+						if (targetPet.getOwner() != player)
+						{
+							if (targetPet.getOwner().isReviveRequested())
+							{
+								if (targetPet.getOwner().isRevivingPet())
+									player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.RES_HAS_ALREADY_BEEN_PROPOSED)); // Resurrection is already been proposed.
+								else
+									player.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.CANNOT_RES_PET2)); // A pet cannot be resurrected while it's owner is in the process of resurrecting.
+								condGood = false;
+							}
+						}
+					}
+				}
+				
+				if (condGood)
+				{
+					if (!onlyFirst)
+					{
+						targetList.add(target);
+						return targetList.toArray(new L2Object[targetList.size()]);
+					}
+					else
+						return new L2Character[] { target };
+				}
+			}
+		}
+		activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+		return _emptyTargetList;
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_CORPSE_PLAYER;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetEnemySummon.java

@@ -0,0 +1,40 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Summon;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetEnemySummon implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		if(target instanceof L2Summon)
+		{
+			L2Summon targetSummon = (L2Summon)target;
+			if (activeChar instanceof L2PcInstance && activeChar.getPet() != targetSummon && !targetSummon.isDead()
+					&& (targetSummon.getOwner().getPvpFlag() != 0 || targetSummon.getOwner().getKarma() > 0)
+					|| (targetSummon.getOwner().isInsideZone(L2Character.ZONE_PVP) && ((L2PcInstance)activeChar).isInsideZone(L2Character.ZONE_PVP))
+					|| (targetSummon.getOwner().isInDuel() && ((L2PcInstance)activeChar).isInDuel() && targetSummon.getOwner().getDuelId() == ((L2PcInstance)activeChar).getDuelId()))
+				return new L2Character[]{targetSummon};
+		}
+		return _emptyTargetList;
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_ENEMY_SUMMON;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetFlagPole.java

@@ -0,0 +1,29 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetFlagPole implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		return new L2Character[] { activeChar };
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_FLAGPOLE;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetFrontArea.java

@@ -0,0 +1,91 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+import com.l2jserver.gameserver.util.Util;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetFrontArea implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (((target == null || target == activeChar || target.isAlikeDead()) && skill.getCastRange() >= 0) || (!(target instanceof L2Attackable || target instanceof L2Playable)))
+		{
+			activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+			return _emptyTargetList;
+		}
+		
+		final L2Character origin;
+		final boolean srcInArena = (activeChar.isInsideZone(L2Character.ZONE_PVP) && !activeChar.isInsideZone(L2Character.ZONE_SIEGE));
+		final int radius = skill.getSkillRadius();
+		
+		if (skill.getCastRange() >= 0)
+		{
+			if (!L2Skill.checkForAreaOffensiveSkills(activeChar, target, skill, srcInArena))
+				return _emptyTargetList;
+			
+			if (onlyFirst)
+				return new L2Character[] { target };
+			
+			origin = target;
+			targetList.add(origin); // Add target to target list
+		}
+		else
+			origin = activeChar;
+		
+		final Collection<L2Character> objs = activeChar.getKnownList().getKnownCharacters();
+		for (L2Character obj : objs)
+		{
+			if (!(obj instanceof L2Attackable || obj instanceof L2Playable))
+				continue;
+			
+			if (obj == origin)
+				continue;
+			
+			if (Util.checkIfInRange(radius, origin, obj, true))
+			{
+				if (!obj.isInFrontOf(activeChar))
+					continue;
+				
+				if (!L2Skill.checkForAreaOffensiveSkills(activeChar, obj, skill, srcInArena))
+					continue;
+				
+				if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+					break;
+				
+				targetList.add(obj);
+			}
+		}
+		
+		if (targetList.isEmpty())
+			return _emptyTargetList;
+		
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_FRONT_AREA;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetFrontAura.java

@@ -0,0 +1,84 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.model.actor.L2Playable;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.templates.skills.L2SkillType;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetFrontAura implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		final boolean srcInArena = (activeChar.isInsideZone(L2Character.ZONE_PVP) && !activeChar.isInsideZone(L2Character.ZONE_SIEGE));
+		
+		final L2PcInstance sourcePlayer = activeChar.getActingPlayer();
+		
+		final Collection<L2Character> objs = activeChar.getKnownList().getKnownCharactersInRadius(skill.getSkillRadius());
+		
+		if (skill.getSkillType() == L2SkillType.DUMMY)
+		{
+			if (onlyFirst)
+				return new L2Character[] { activeChar };
+			
+			targetList.add(activeChar);
+			for (L2Character obj : objs)
+			{
+				if (!(obj == activeChar || obj == sourcePlayer || obj instanceof L2Npc || obj instanceof L2Attackable))
+					continue;
+				
+				if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+					break;
+				targetList.add(obj);
+			}
+		}
+		else
+		{
+			for (L2Character obj : objs)
+			{
+				if (obj instanceof L2Attackable || obj instanceof L2Playable)
+				{
+					
+					if (!obj.isInFrontOf(activeChar))
+						continue;
+					
+					if (!L2Skill.checkForAreaOffensiveSkills(activeChar, obj, skill, srcInArena))
+						continue;
+					
+					if (onlyFirst)
+						return new L2Character[] { obj };
+					
+					if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+						break;
+					targetList.add(obj);
+				}
+			}
+		}
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_FRONT_AURA;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetGround.java

@@ -0,0 +1,30 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetGround implements ISkillTargetTypeHandler
+{
+	
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		return new L2Character[] { activeChar };
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_GROUND;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetHoly.java

@@ -0,0 +1,37 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.instance.L2ArtefactInstance;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetHoly implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		if (activeChar instanceof L2PcInstance)
+		{
+			if (target instanceof L2ArtefactInstance)
+				return new L2Character[] { target };
+		}
+		
+		return _emptyTargetList;
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_HOLY;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetOne.java

@@ -0,0 +1,61 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetOne implements ISkillTargetTypeHandler
+{
+	
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		boolean canTargetSelf = false;
+		switch (skill.getSkillType())
+		{
+			case BUFF:
+			case HEAL:
+			case HOT:
+			case HEAL_PERCENT:
+			case MANARECHARGE:
+			case MANA_BY_LEVEL:
+			case MANAHEAL:
+			case NEGATE:
+			case CANCEL_DEBUFF:
+			case COMBATPOINTHEAL:
+			case BALANCE_LIFE:
+			case HPMPCPHEAL_PERCENT:
+			case HPMPHEAL_PERCENT:
+			case HPCPHEAL_PERCENT:
+				canTargetSelf = true;
+				break;
+		}
+		
+		// Check for null target or any other invalid target
+		if (target == null || target.isDead() || (target == activeChar && !canTargetSelf))
+		{
+			activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+			return _emptyTargetList;
+		}
+		
+		// If a target is found, return it in a table else send a system message TARGET_IS_INCORRECT
+		return new L2Character[] { target };
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_ONE;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetOwnerPet.java

@@ -0,0 +1,37 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Summon;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetOwnerPet implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		if (activeChar instanceof L2Summon)
+		{
+			target = ((L2Summon) activeChar).getOwner();
+			if (target != null && !target.isDead())
+				return new L2Character[] { target };
+		}
+		
+		return _emptyTargetList;
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_OWNER_PET;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetParty.java

@@ -0,0 +1,73 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Summon;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetParty implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (onlyFirst)
+			return new L2Character[] { activeChar };
+		
+		targetList.add(activeChar);
+		
+		final int radius = skill.getSkillRadius();
+		
+		L2PcInstance player = activeChar.getActingPlayer();
+		if (activeChar instanceof L2Summon)
+		{
+			if (L2Skill.addCharacter(activeChar, player, radius, false))
+				targetList.add(player);
+		}
+		else if (activeChar instanceof L2PcInstance)
+		{
+			if (L2Skill.addSummon(activeChar, player, radius, false))
+				targetList.add(player.getPet());
+		}
+		
+		if (activeChar.isInParty())
+		{
+			// Get a list of Party Members
+			for (L2PcInstance partyMember : activeChar.getParty().getPartyMembers())
+			{
+				if (partyMember == null || partyMember == player)
+					continue;
+				
+				if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+					break;
+				
+				if (L2Skill.addCharacter(activeChar, partyMember, radius, false))
+					targetList.add(partyMember);
+				
+				if (L2Skill.addSummon(activeChar, partyMember, radius, false))
+					targetList.add(partyMember.getPet());
+			}
+		}
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_PARTY;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetPartyClan.java

@@ -0,0 +1,111 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.Collection;
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.entity.TvTEvent;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetPartyClan implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (onlyFirst)
+			return new L2Character[] { activeChar };
+		
+		final L2PcInstance player = activeChar.getActingPlayer();
+		
+		if (player == null)
+			return _emptyTargetList;
+		
+		targetList.add(player);
+		
+		final int radius = skill.getSkillRadius();
+		final boolean hasClan = player.getClan() != null;
+		final boolean hasParty = player.isInParty();
+		
+		if (L2Skill.addSummon(activeChar, player, radius, false))
+			targetList.add(player.getPet());
+		
+		// if player in clan and not in party
+		if (!(hasClan || hasParty))
+			return targetList.toArray(new L2Character[targetList.size()]);
+		
+		// Get all visible objects in a spherical area near the L2Character
+		final Collection<L2PcInstance> objs = activeChar.getKnownList().getKnownPlayersInRadius(radius);
+		for (L2PcInstance obj : objs)
+		{
+			if (obj == null)
+				continue;
+			
+			// olympiad mode - adding only own side
+			if (player.isInOlympiadMode())
+			{
+				if (!obj.isInOlympiadMode())
+					continue;
+				if (player.getOlympiadGameId() != obj.getOlympiadGameId())
+					continue;
+				if (player.getOlympiadSide() != obj.getOlympiadSide())
+					continue;
+			}
+			
+			if (player.isInDuel())
+			{
+				if (player.getDuelId() != obj.getDuelId())
+					continue;
+				
+				if (hasParty && obj.isInParty() && player.getParty().getPartyLeaderOID() != obj.getParty().getPartyLeaderOID())
+					continue;
+			}
+			
+			if (!((hasClan && obj.getClanId() == player.getClanId()) || (hasParty && obj.isInParty() && player.getParty().getPartyLeaderOID() == obj.getParty().getPartyLeaderOID())))
+				continue;
+			
+			// Don't add this target if this is a Pc->Pc pvp
+			// casting and pvp condition not met
+			if (!player.checkPvpSkill(obj, skill))
+				continue;
+			
+			if (!TvTEvent.checkForTvTSkill(player, obj, skill))
+				continue;
+			
+			if (!onlyFirst && L2Skill.addSummon(activeChar, obj, radius, false))
+				targetList.add(obj.getPet());
+			
+			if (!L2Skill.addCharacter(activeChar, obj, radius, false))
+				continue;
+			
+			if (onlyFirst)
+				return new L2Character[] { obj };
+			
+			if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+				break;
+			
+			targetList.add(obj);
+		}
+		
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_PARTY_CLAN;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetPartyMember.java

@@ -0,0 +1,60 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Summon;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetPartyMember implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		if ((target != null
+				&& target == activeChar)
+				|| (target != null
+						&& activeChar.isInParty()
+						&& target.isInParty()
+						&& activeChar.getParty().getPartyLeaderOID() == target.getParty().getPartyLeaderOID())
+						|| (target != null
+								&& activeChar instanceof L2PcInstance
+								&& target instanceof L2Summon
+								&& activeChar.getPet() == target)
+								|| (target != null
+										&& activeChar instanceof L2Summon
+										&& target instanceof L2PcInstance
+										&& activeChar == target.getPet()))
+		{
+			if (!target.isDead())
+			{
+				// If a target is found, return it in a table else send a system message TARGET_IS_INCORRECT
+				return new L2Character[] { target };
+			}
+			else
+				return _emptyTargetList;
+		}
+		else
+		{
+			activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+			return _emptyTargetList;
+		}
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_PARTY_MEMBER;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetPartyNotMe.java

@@ -0,0 +1,78 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Summon;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.util.Util;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetPartyNotMe implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (onlyFirst)
+			return new L2Character[] { activeChar };
+		
+		L2PcInstance player = null;
+		
+		if (activeChar instanceof L2Summon)
+		{
+			player = ((L2Summon) activeChar).getOwner();
+			targetList.add(player);
+		}
+		else if (activeChar instanceof L2PcInstance)
+		{
+			player = (L2PcInstance) activeChar;
+			if (activeChar.getPet() != null)
+				targetList.add(activeChar.getPet());
+		}
+		
+		if (activeChar.getParty() != null)
+		{
+			List<L2PcInstance> partyList = activeChar.getParty().getPartyMembers();
+			
+			for (L2PcInstance partyMember : partyList)
+			{
+				if (partyMember == null)
+					continue;
+				else if (partyMember == player)
+					continue;
+				else if (!partyMember.isDead() && Util.checkIfInRange(skill.getSkillRadius(), activeChar, partyMember, true))
+				{
+					if (skill.getMaxTargets() > -1 && targetList.size() >= skill.getMaxTargets())
+						break;
+					
+					targetList.add(partyMember);
+					
+					if (partyMember.getPet() != null && !partyMember.getPet().isDead())
+					{
+						targetList.add(partyMember.getPet());
+					}
+				}
+			}
+		}
+		return targetList.toArray(new L2Character[targetList.size()]);
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_PARTY_NOTME;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetPartyOther.java

@@ -0,0 +1,64 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetPartyOther implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		if (target != null && target != activeChar
+				&& activeChar.isInParty() && target.isInParty()
+				&& activeChar.getParty().getPartyLeaderOID() == target.getParty().getPartyLeaderOID())
+		{
+			if (!target.isDead())
+			{
+				if (target instanceof L2PcInstance)
+				{
+					switch (skill.getId())
+					{
+						// FORCE BUFFS may cancel here but there should be a proper condition
+						case 426:
+							if (!((L2PcInstance) target).isMageClass())
+								return new L2Character[] { target };
+							else
+								return _emptyTargetList;
+						case 427:
+							if (((L2PcInstance) target).isMageClass())
+								return new L2Character[] { target };
+							else
+								return _emptyTargetList;
+					}
+				}
+				return new L2Character[] { target };
+			}
+			else
+				return _emptyTargetList;
+		}
+		else
+		{
+			activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+			return _emptyTargetList;
+		}
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_PARTY_OTHER;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetPet.java

@@ -0,0 +1,33 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetPet implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		target = activeChar.getPet();
+		if (target != null && !target.isDead())
+			return new L2Character[] { target };
+		
+		return _emptyTargetList;
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_PET;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetSelf.java

@@ -0,0 +1,30 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetSelf implements ISkillTargetTypeHandler
+{
+	
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		return new L2Character[] { activeChar };
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_SELF;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetSummon.java

@@ -0,0 +1,34 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.instance.L2SummonInstance;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetSummon implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		target = activeChar.getPet();
+		if (target != null && !target.isDead() && target instanceof L2SummonInstance)
+			return new L2Character[] { target };
+		
+		return _emptyTargetList;
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_SUMMON;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetUndead.java

@@ -0,0 +1,57 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.model.actor.instance.L2SummonInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetUndead implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (target instanceof L2Npc || target instanceof L2SummonInstance)
+		{
+			if (!target.isUndead() || target.isDead())
+			{
+				activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+				return _emptyTargetList;
+			}
+			
+			if (!onlyFirst)
+				targetList.add(target);
+			else
+				return new L2Character[] { target };
+			
+			return targetList.toArray(new L2Object[targetList.size()]);
+		}
+		else
+		{
+			activeChar.sendPacket(SystemMessage.getSystemMessage(SystemMessageId.TARGET_IS_INCORRECT));
+			return _emptyTargetList;
+		}
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_UNDEAD;
+	}
+}

L2J_DataPack_BETA/data/scripts/handlers/targethandlers/TargetUnlockable.java

@@ -0,0 +1,47 @@
+/**
+ * 
+ */
+package handlers.targethandlers;
+
+import java.util.List;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.handler.ISkillTargetTypeHandler;
+import com.l2jserver.gameserver.model.L2Object;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.instance.L2ChestInstance;
+import com.l2jserver.gameserver.model.actor.instance.L2DoorInstance;
+
+/**
+ * @author UnAfraid
+ *
+ */
+public class TargetUnlockable implements ISkillTargetTypeHandler
+{
+	@Override
+	public L2Object[] getTargetList(L2Skill skill, L2Character activeChar, boolean onlyFirst, L2Character target)
+	{
+		List<L2Character> targetList = new FastList<L2Character>();
+		if (!(target instanceof L2DoorInstance) && !(target instanceof L2ChestInstance))
+		{
+			return _emptyTargetList;
+		}
+		
+		if (!onlyFirst)
+		{
+			targetList.add(target);
+			return targetList.toArray(new L2Object[targetList.size()]);
+		}
+		else
+			return new L2Character[] { target };
+	}
+	
+	@Override
+	public Enum<SkillTargetType> getTargetType()
+	{
+		return SkillTargetType.TARGET_UNLOCKABLE;
+	}
+}