Event Engine (nuLL)

[Swarlog]

Creado para L2J-Server H5 BETA, creado por nuLL

Código [Seleccionar] Expandir

### Eclipse Workspace Patch 1.0
#P L2J_Server_BETA
Index: java/com/l2jserver/gameserver/model/gameeventengine/ctf/CtFEvent.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/ctf/CtFEvent.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/ctf/CtFEvent.java	(working copy)
@@ -0,0 +1,393 @@
+/*
+ * 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.gameeventengine.ctf;
+
+import java.util.List;
+
+import com.l2jserver.gameserver.datatables.ItemTable;
+import com.l2jserver.gameserver.enums.Team;
+import com.l2jserver.gameserver.model.L2Spawn;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.model.actor.L2Summon;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventManager;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventPlayer;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventTeam;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventTeleporter;
+import com.l2jserver.gameserver.model.gameeventengine.TeamGameEvent;
+import com.l2jserver.gameserver.model.gameeventengine.TeamGameEventConfig.GameEventTeamConfig;
+import com.l2jserver.gameserver.model.itemcontainer.Inventory;
+import com.l2jserver.gameserver.model.items.instance.L2ItemInstance;
+import com.l2jserver.gameserver.network.serverpackets.ExShowScreenMessage;
+import com.l2jserver.util.NpcUtils;
+import com.l2jserver.util.Rnd;
+
+/**
+ * @author nuLL
+ */
+public final class CtFEvent extends TeamGameEvent
+{
+	private L2Spawn redFlag = null;
+	private L2Spawn blueFlag = null;
+	
+	private static final int BLUE_FLAG_ID = 13560;
+	private static final int RED_FLAG_ID = 13561;
+	
+	private static final int BLUE_NPC_ID = 35426;
+	private static final int RED_NPC_ID = 35423;
+	
+	private static CtFEvent _instance;
+	
+	public CtFEvent()
+	{
+		_instance = this;
+	}
+	
+	public static CtFEvent getInstance()
+	{
+		if (_instance == null)
+		{
+			_instance = new CtFEvent();
+		}
+		return _instance;
+	}
+	
+	@Override
+	public CtFConfig getConfigs()
+	{
+		return CtFConfig.getInstance();
+	}
+	
+	@Override
+	public void init()
+	{
+		eventName = "Capture the Flag";
+		
+		List<GameEventTeamConfig> teamsConfig = getConfigs().TEAMS;
+		teams = new GameEventTeam[teamsConfig.size()];
+		for (int i = 0; i < teamsConfig.size(); i++)
+		{
+			teams[i] = new GameEventTeam(teamsConfig.get(i).getId(), teamsConfig.get(i).getName(), teamsConfig.get(i).getColor(), teamsConfig.get(i).getCoordinates());
+		}
+		
+		setState(EventState.INACTIVE);
+		
+		GameEventManager.getInstance().registerEvent(getInstance());
+	}
+	
+	@Override
+	public boolean start()
+	{
+		if (getCountPlayers() >= getConfigs().MIN_PARTICIPANTS)
+		{
+			createInstance();
+			setState(EventState.STARTED);
+			closeDoors();
+			spawnFlags();
+			teleportPlayersToArena();
+			return true;
+		}
+		clear();
+		setState(EventState.INACTIVE);
+		return false;
+	}
+	
+	/**
+	 * Method called to spawn a team flag
+	 * @param teamId as Integer
+	 * @return L2Spawn
+	 */
+	private L2Spawn spawnFlag(int teamId)
+	{
+		return NpcUtils.spawnSingle(teamId == 1 ? BLUE_NPC_ID : RED_NPC_ID, getConfigs().FLAGS.get(teamId), eventInstance);
+	}
+	
+	/**
+	 * Method called to drop a team flag from a player and restore it to its base id necessary
+	 * @param player as L2PcInstance
+	 * @param onBase as boolean
+	 */
+	private void dropFlag(L2PcInstance player, boolean onBase)
+	{
+		if ((player != null) && player.isTerritoryFlagEquipped())
+		{
+			L2ItemInstance flag = player.getActiveWeaponInstance();
+			
+			if (flag != null)
+			{
+				removeFlag(player);
+				
+				if (flag.getId() == BLUE_FLAG_ID)
+				{
+					redFlag.getLastSpawn().setLocationInvisible(onBase ? getConfigs().FLAGS.get(2) : player.getLocation());
+					redFlag.getLastSpawn().decayMe();
+					redFlag.getLastSpawn().spawnMe();
+				}
+				else if (flag.getId() == RED_FLAG_ID)
+				{
+					blueFlag.getLastSpawn().setLocationInvisible(onBase ? getConfigs().FLAGS.get(1) : player.getLocation());
+					blueFlag.getLastSpawn().decayMe();
+					blueFlag.getLastSpawn().spawnMe();
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Method called to add a team flag to a player
+	 * @param player as L2PcInstance
+	 */
+	private void addFlagToPlayer(L2PcInstance player)
+	{
+		L2ItemInstance weaponRightHand = player.getInventory().getPaperdollItem(Inventory.PAPERDOLL_RHAND);
+		L2ItemInstance weaponLeftHand = player.getInventory().getPaperdollItem(Inventory.PAPERDOLL_LHAND);
+		
+		if (weaponRightHand != null)
+		{
+			player.getInventory().unEquipItemInSlotAndRecord(Inventory.PAPERDOLL_RHAND);
+		}
+		
+		if (weaponLeftHand != null)
+		{
+			player.getInventory().unEquipItemInSlotAndRecord(Inventory.PAPERDOLL_LHAND);
+		}
+		
+		int flagId = player.getTeam() == Team.BLUE ? BLUE_FLAG_ID : RED_FLAG_ID;
+		
+		player.getInventory().equipItem(ItemTable.getInstance().createItem("CtF Event", flagId, 1, player, null));
+		
+		if (flagId == BLUE_FLAG_ID)
+		{
+			redFlag.getLastSpawn().decayMe();
+		}
+		else
+		{
+			blueFlag.getLastSpawn().decayMe();
+		}
+		
+		player.getInventory().blockAllItems();
+		
+		player.broadcastUserInfo();
+		
+		player.sendPacket(new ExShowScreenMessage("You got the enemy's flag! Run back!", 5000));
+	}
+	
+	/**
+	 * Method called to remove a team flag from a player
+	 * @param player as L2PcInstance
+	 */
+	private void removeFlag(L2PcInstance player)
+	{
+		if ((player != null) && player.isTerritoryFlagEquipped())
+		{
+			L2ItemInstance flag = player.getActiveWeaponInstance();
+			if ((flag != null) && ((flag.getId() == BLUE_FLAG_ID) || (flag.getId() == RED_FLAG_ID)))
+			{
+				player.getInventory().unblock();
+				player.getInventory().destroyItem("CtF Event", flag, player, null);
+				player.broadcastUserInfo();
+			}
+		}
+	}
+	
+	/**
+	 * Method called to restore the flag to its base
+	 * @param player as L2PcInstance
+	 */
+	private void flagToBase(L2PcInstance player)
+	{
+		dropFlag(player, true);
+		
+		GameEventTeam team = getParticipantTeam(player.getObjectId());
+		
+		if (team != null)
+		{
+			team.increasePoints();
+			
+			sysMsgToAllParticipants("Player: " + player.getName() + " has scored for the " + team.getName() + " team!");
+		}
+	}
+	
+	/**
+	 * Method called to spawn team flags on its base
+	 */
+	public void spawnFlags()
+	{
+		for (GameEventTeam team : teams)
+		{
+			if (team.getId() == 1)
+			{
+				blueFlag = spawnFlag(team.getId());
+			}
+			else
+			{
+				redFlag = spawnFlag(team.getId());
+			}
+		}
+	}
+	
+	/**
+	 * Method called when a player is killed
+	 * @param killerCharacter as L2Character
+	 * @param killedPlayerInstance as L2PcInstance
+	 */
+	@Override
+	public void onKill(L2Character killerCharacter, L2PcInstance killedPlayerInstance)
+	{
+		if ((killedPlayerInstance == null) || !isRunning())
+		{
+			return;
+		}
+		
+		GameEventTeam killedTeam = getParticipantTeam(killedPlayerInstance.getObjectId());
+		
+		if (killedTeam == null)
+		{
+			return;
+		}
+		
+		GameEventPlayer killedEventPlayer = killedTeam.getEventPlayer(killedPlayerInstance.getObjectId());
+		
+		if ((killedEventPlayer == null) || (killerCharacter == null))
+		{
+			return;
+		}
+		
+		L2PcInstance killerPlayerInstance = null;
+		
+		if (killerCharacter.isSummon())
+		{
+			killerPlayerInstance = ((L2Summon) killerCharacter).getOwner();
+			
+			if (killerPlayerInstance == null)
+			{
+				return;
+			}
+		}
+		else if (killerCharacter.isPlayer())
+		{
+			killerPlayerInstance = (L2PcInstance) killerCharacter;
+		}
+		else
+		{
+			return;
+		}
+		
+		GameEventTeam killerTeam = getParticipantTeam(killerPlayerInstance.getObjectId());
+		
+		if (killerTeam == null)
+		{
+			return;
+		}
+		
+		if (getConfigs().REQUIRE_MIN_FRAGS_TO_REWARD)
+		{
+			GameEventPlayer killerEventPlayer = killerTeam.getEventPlayer(killerPlayerInstance.getObjectId());
+			killerEventPlayer.increaseKills();
+		}
+		
+		dropFlag(killedPlayerInstance, true);
+		
+		new GameEventTeleporter(killedEventPlayer, killedTeam.getCoordinates(), false);
+		
+		if (getConfigs().ALLOW_KILL_BONUS)
+		{
+			giveKillBonus(killerPlayerInstance);
+		}
+	}
+	
+	/**
+	 * Method called when a player talks with an event npc
+	 * @param player as L2PcInstance
+	 * @param npc as L2Npc
+	 * @return boolean: true if implemented by the event, otherwise false
+	 */
+	@Override
+	public boolean talkWithNpc(L2PcInstance player, L2Npc npc)
+	{
+		if ((getState() == EventState.STARTED) && (player != null) && isParticipant(player.getObjectId()))
+		{
+			if (npc.getId() == BLUE_NPC_ID)
+			{
+				if (player.isTerritoryFlagEquipped() && (player.getTeam() == Team.BLUE))
+				{
+					flagToBase(player);
+				}
+				else if (!player.isTerritoryFlagEquipped() && (player.getTeam() == Team.RED) && npc.isVisible())
+				{
+					addFlagToPlayer(player);
+				}
+				return true;
+			}
+			
+			if (npc.getId() == RED_NPC_ID)
+			{
+				if (player.isTerritoryFlagEquipped() && (player.getTeam() == Team.RED))
+				{
+					flagToBase(player);
+				}
+				else if (!player.isTerritoryFlagEquipped() && (player.getTeam() == Team.BLUE) && npc.isVisible())
+				{
+					addFlagToPlayer(player);
+				}
+				return true;
+			}
+		}
+		return false;
+	}
+	
+	/**
+	 * Called when a player logs out
+	 * @param playerInstance as L2PcInstance
+	 */
+	@Override
+	public void onLogout(L2PcInstance playerInstance)
+	{
+		if ((playerInstance != null) && (isRunning() || isRegistrating()))
+		{
+			dropFlag(playerInstance, true);
+			
+			if (removeParticipant(playerInstance))
+			{
+				playerInstance.setXYZInvisible((83447 + Rnd.get(101)) - 50, (148638 + Rnd.get(101)) - 50, -3400); // Giran
+			}
+		}
+	}
+	
+	/**
+	 * Method called to clear event attributes
+	 */
+	@Override
+	protected void clear()
+	{
+		for (GameEventTeam team : teams)
+		{
+			for (GameEventPlayer eventPlayer : team.getParticipatedPlayers().values())
+			{
+				if ((eventPlayer != null) && (eventPlayer.getPlayer() != null))
+				{
+					removeFlag(eventPlayer.getPlayer());
+				}
+			}
+		}
+		
+		super.clear();
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/GameEventConfig.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/GameEventConfig.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/GameEventConfig.java	(working copy)
@@ -0,0 +1,56 @@
+/*
+ * 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.gameeventengine;
+
+/**
+ * @author nuLL
+ */
+public abstract class GameEventConfig
+{
+	public String[] EVENT_INTERVAL;
+	public byte EVENT_DURATION_TIME = 10;
+	public byte TELEPORT_TIME = 15;
+	public byte REGISTRATION_TIME = 10;
+	public short MIN_PARTICIPANTS = 2;
+	public short MAX_PARTICIPANTS = 10;
+	public byte MIN_LEVEL = 1;
+	public byte MAX_LEVEL = 85;
+	public boolean ALLOW_TAKE_ITEM = false;
+	public short TAKE_ITEM_ID = 0;
+	public int TAKE_COUNT = 0;
+	public boolean ALLOW_KILL_BONUS = false;
+	public short KILL_BONUS_ID = 0;
+	public int KILL_BONUS_COUNT = 0;
+	public boolean STOP_ALL_EFFECTS = true;
+	public boolean ALLOW_MULTIPLE_BOXES = false;
+	public int[] LIST_MAGE_SUPPORT;
+	public int[] LIST_FIGHTER_SUPPORT;
+	public int[] RESTRICT_ITEMS;
+	public int[] RESTRICT_SKILLS;
+	public boolean HIDE_PLAYERS_IDENTITY = false;
+	public boolean REWARD_EVENT_TIE = false;
+	public int[][] REWARDS;
+	public String INSTANCE_FILE = "";
+	public boolean ALLOW_POTIONS = false;
+	public boolean ALLOW_SCROLLS = false;
+	public boolean ALLOW_SUMMON_BY_ITEM = false;
+	public boolean REQUIRE_MIN_FRAGS_TO_REWARD = false;
+	public byte MIN_FRAGS_TO_REWARD = 0;
+	public byte PLAYER_CREDITS = 0;
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/IGameEventConfig.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/IGameEventConfig.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/IGameEventConfig.java	(working copy)
@@ -0,0 +1,27 @@
+/*
+ * 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.gameeventengine;
+
+/**
+ * @author nuLL
+ */
+public interface IGameEventConfig
+{
+	public void load();
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/dm/DMConfig.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/dm/DMConfig.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/dm/DMConfig.java	(working copy)
@@ -0,0 +1,299 @@
+/*
+ * 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.gameeventengine.dm;
+
+import java.io.File;
+import java.util.logging.Logger;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+import com.l2jserver.gameserver.model.gameeventengine.IGameEventConfig;
+import com.l2jserver.gameserver.model.gameeventengine.IndividualGameEventConfig;
+
+/**
+ * @author nuLL
+ */
+public class DMConfig extends IndividualGameEventConfig implements IGameEventConfig
+{
+	private static final Logger _log = Logger.getLogger(DMConfig.class.getName());
+	
+	public int[][] REWARDS_1ST_PLACE;
+	public int[][] REWARDS_2ND_PLACE;
+	public int[][] REWARDS_3RD_PLACE;
+	
+	private static DMConfig _instance;
+	
+	private DMConfig()
+	{
+		load();
+	}
+	
+	public static DMConfig getInstance()
+	{
+		if (_instance == null)
+		{
+			_instance = new DMConfig();
+		}
+		return _instance;
+	}
+	
+	@Override
+	public void load()
+	{
+		try
+		{
+			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+			factory.setValidating(false);
+			factory.setIgnoringComments(true);
+			
+			File file = new File("./config/events/DeathMatch.xml");
+			
+			Document doc = factory.newDocumentBuilder().parse(file);
+			
+			for (Node n = doc.getFirstChild(); n != null; n = n.getNextSibling())
+			{
+				
+				if (!"dm".equalsIgnoreCase(n.getNodeName()))
+				{
+					continue;
+				}
+				
+				NamedNodeMap attrs = n.getAttributes();
+				
+				for (Node cd = n.getFirstChild(); cd != null; cd = cd.getNextSibling())
+				{
+					if ("InstanceFile".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						INSTANCE_FILE = attrs.getNamedItem("val").getNodeValue();
+					}
+					else if ("EventTimeInterval".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						EVENT_INTERVAL = attrs.getNamedItem("val").getNodeValue().split(",");
+					}
+					else if ("Duration".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						EVENT_DURATION_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("Participants".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_PARTICIPANTS = Short.parseShort(attrs.getNamedItem("min").getNodeValue());
+						MAX_PARTICIPANTS = Short.parseShort(attrs.getNamedItem("max").getNodeValue());
+					}
+					else if ("Level".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_LEVEL = Byte.parseByte(attrs.getNamedItem("min").getNodeValue());
+						MAX_LEVEL = Byte.parseByte(attrs.getNamedItem("max").getNodeValue());
+					}
+					else if ("TimeToRegistration".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REGISTRATION_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("TimeToTeleport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						TELEPORT_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowTakeItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_TAKE_ITEM = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("TakeItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						TAKE_ITEM_ID = Short.parseShort(attrs.getNamedItem("id").getNodeValue());
+						TAKE_COUNT = Integer.parseInt(attrs.getNamedItem("count").getNodeValue());
+					}
+					else if ("AllowKillBonus".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_KILL_BONUS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("KillReward".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						KILL_BONUS_ID = Short.parseShort(attrs.getNamedItem("id").getNodeValue());
+						KILL_BONUS_COUNT = Integer.parseInt(attrs.getNamedItem("count").getNodeValue());
+					}
+					else if ("PlayerEventCoordinates".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						int x = Integer.parseInt(attrs.getNamedItem("x").getNodeValue());
+						int y = Integer.parseInt(attrs.getNamedItem("y").getNodeValue());
+						int z = Integer.parseInt(attrs.getNamedItem("z").getNodeValue());
+						int h = Integer.parseInt(attrs.getNamedItem("h").getNodeValue());
+						EVENT_COORDINATES = new int[]
+						{
+							x,
+							y,
+							z,
+							h
+						};
+					}
+					else if ("StopAllEffects".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						STOP_ALL_EFFECTS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("HidePlayersIdentity".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						HIDE_PLAYERS_IDENTITY = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowMultipleBoxes".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_MULTIPLE_BOXES = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("Rewards1stPlace".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] itemIds = attrs.getNamedItem("id").getNodeValue().split(",");
+						String[] counts = attrs.getNamedItem("count").getNodeValue().split(",");
+						REWARDS_1ST_PLACE = new int[itemIds.length][];
+						for (int i = 0; i < itemIds.length; i++)
+						{
+							REWARDS_1ST_PLACE[i] = new int[]
+							{
+								Integer.parseInt(itemIds[i]),
+								Integer.parseInt(counts[i])
+							};
+						}
+					}
+					else if ("Rewards2ndPlace".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] itemIds = attrs.getNamedItem("id").getNodeValue().split(",");
+						String[] counts = attrs.getNamedItem("count").getNodeValue().split(",");
+						REWARDS_2ND_PLACE = new int[itemIds.length][];
+						for (int i = 0; i < itemIds.length; i++)
+						{
+							REWARDS_2ND_PLACE[i] = new int[]
+							{
+								Integer.parseInt(itemIds[i]),
+								Integer.parseInt(counts[i])
+							};
+						}
+					}
+					else if ("Rewards3rdPlace".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] itemIds = attrs.getNamedItem("id").getNodeValue().split(",");
+						String[] counts = attrs.getNamedItem("count").getNodeValue().split(",");
+						REWARDS_3RD_PLACE = new int[itemIds.length][];
+						for (int i = 0; i < itemIds.length; i++)
+						{
+							REWARDS_3RD_PLACE[i] = new int[]
+							{
+								Integer.parseInt(itemIds[i]),
+								Integer.parseInt(counts[i])
+							};
+						}
+					}
+					else if ("RewardTie".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REWARD_EVENT_TIE = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("ListMageSupport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						LIST_MAGE_SUPPORT = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							LIST_MAGE_SUPPORT[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("ListFighterSupport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						LIST_FIGHTER_SUPPORT = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							LIST_FIGHTER_SUPPORT[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("RestrictItems".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] items = attrs.getNamedItem("val").getNodeValue().split(",");
+						RESTRICT_ITEMS = new int[items.length];
+						for (int i = 0; i < items.length; i++)
+						{
+							RESTRICT_ITEMS[i] = Integer.parseInt(items[i]);
+						}
+						
+					}
+					else if ("RestrictSkills".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						RESTRICT_SKILLS = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							RESTRICT_SKILLS[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("AllowPotions".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_POTIONS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowScrolls".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_SCROLLS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowSummonByItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_SUMMON_BY_ITEM = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("RequireMinFragsToReward".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REQUIRE_MIN_FRAGS_TO_REWARD = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("MinFragsRequired".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_FRAGS_TO_REWARD = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+				}
+			}
+		}
+		catch (Exception e)
+		{
+			_log.warning("Error parsing DeathMatch.xml, by error: " + e.getMessage());
+		}
+	}
+	
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/GameEventManager.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/GameEventManager.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/GameEventManager.java	(working copy)
@@ -0,0 +1,311 @@
+/*
+ * 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.gameeventengine;
+
+import java.util.Calendar;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.concurrent.ScheduledFuture;
+import java.util.logging.Logger;
+
+import com.l2jserver.gameserver.Announcements;
+import com.l2jserver.gameserver.ThreadPoolManager;
+
+/**
+ * @author nuLL
+ */
+public class GameEventManager
+{
+	protected static final Logger _log = Logger.getLogger(GameEventManager.class.getName());
+	
+	private static GameEventManager _instance;
+	private final Map<String, GameEvent> _events;
+	private GameEvent event;
+	private GameEventStartTask task;
+	private String _currentEventName = "-";
+	private String _nextEventInfo = "-";
+	
+	public GameEventManager()
+	{
+		_events = new HashMap<>();
+		event = null;
+	}
+	
+	public static GameEventManager getInstance()
+	{
+		if (_instance == null)
+		{
+			_instance = new GameEventManager();
+		}
+		return _instance;
+	}
+	
+	public void registerEvent(GameEvent gameEvent)
+	{
+		_events.put(gameEvent.getName(), gameEvent);
+		_log.info("Game Event Engine - Event registered: " + gameEvent.getName());
+	}
+	
+	public GameEvent getEvent()
+	{
+		return event;
+	}
+	
+	public void startRegistration()
+	{
+		_currentEventName = getEvent().getName();
+		_nextEventInfo = "-";
+		getEvent().startRegistration();
+		Announcements.getInstance().announceToAll(getEvent().getName() + " Event: Registration opened for " + getEvent().getConfigs().REGISTRATION_TIME + " minute(s). Type .join to register!", true);
+		task.setStartTime(System.currentTimeMillis() + (60000L * getEvent().getConfigs().REGISTRATION_TIME));
+		ThreadPoolManager.getInstance().executeGeneral(task);
+	}
+	
+	public void startEvent()
+	{
+		if (!getEvent().start())
+		{
+			Announcements.getInstance().announceToAll(getEvent().getName() + " Event: Event cancelled due to lack of Participation.", true);
+			scheduleNextEvent();
+			_currentEventName = "-";
+		}
+		else
+		{
+			getEvent().sysMsgToAllParticipants(getEvent().getName() + " Event: Teleporting participants to an arena in " + getEvent().getConfigs().TELEPORT_TIME + " second(s).");
+			task.setStartTime(System.currentTimeMillis() + (60000L * getEvent().getConfigs().EVENT_DURATION_TIME));
+			ThreadPoolManager.getInstance().executeGeneral(task);
+		}
+	}
+	
+	public void endEvent()
+	{
+		Announcements.getInstance().announceToAll(getEvent().getName() + " Event: " + getEvent().calculateRewards(), true);
+		getEvent().sysMsgToAllParticipants(getEvent().getName() + " Event: Teleporting back in " + getEvent().getConfigs().TELEPORT_TIME + " second(s).");
+		getEvent().stop();
+		scheduleNextEvent();
+		_currentEventName = "-";
+	}
+	
+	public Calendar nextEventStartTime(GameEvent gameEvent)
+	{
+		Calendar currentTime = Calendar.getInstance();
+		Calendar nextStartTime = null;
+		Calendar testStartTime = null;
+		
+		if (gameEvent.getConfigs().EVENT_INTERVAL != null)
+		{
+			for (String timeOfDay : gameEvent.getConfigs().EVENT_INTERVAL)
+			{
+				testStartTime = Calendar.getInstance();
+				testStartTime.setLenient(true);
+				String[] splitTimeOfDay = timeOfDay.split(":");
+				testStartTime.set(Calendar.HOUR_OF_DAY, Integer.parseInt(splitTimeOfDay[0]));
+				testStartTime.set(Calendar.MINUTE, Integer.parseInt(splitTimeOfDay[1]));
+				if (testStartTime.getTimeInMillis() < currentTime.getTimeInMillis())
+				{
+					testStartTime.add(Calendar.DAY_OF_MONTH, 1);
+				}
+				if ((nextStartTime == null) || (testStartTime.getTimeInMillis() < nextStartTime.getTimeInMillis()))
+				{
+					nextStartTime = testStartTime;
+				}
+			}
+		}
+		
+		return nextStartTime;
+	}
+	
+	public void scheduleNextEvent()
+	{
+		if ((_events != null) && !_events.isEmpty())
+		{
+			Calendar tempNextStartTime = null;
+			Calendar nextStartTime = null;
+			
+			for (GameEvent gameEvent : _events.values())
+			{
+				tempNextStartTime = nextEventStartTime(gameEvent);
+				
+				if (tempNextStartTime == null)
+				{
+					continue;
+				}
+				
+				if (nextStartTime == null)
+				{
+					nextStartTime = tempNextStartTime;
+					event = gameEvent;
+				}
+				else
+				{
+					if (tempNextStartTime.getTimeInMillis() < nextStartTime.getTimeInMillis())
+					{
+						nextStartTime = tempNextStartTime;
+						event = gameEvent;
+					}
+				}
+			}
+			
+			if (nextStartTime != null)
+			{
+				_nextEventInfo = event.getName() + " in " + ((nextStartTime.getTimeInMillis() - System.currentTimeMillis()) / 60000L) + " minutes!";
+				task = new GameEventStartTask(nextStartTime.getTimeInMillis());
+				ThreadPoolManager.getInstance().executeGeneral(task);
+				_log.info("Game Event Engine - Next Event: " + event.getName() + " in " + ((nextStartTime.getTimeInMillis() - System.currentTimeMillis()) / 60000L) + " minutes!");
+			}
+		}
+	}
+	
+	public void skipDelay()
+	{
+		if (task.nextRun.cancel(false))
+		{
+			task.setStartTime(System.currentTimeMillis());
+			ThreadPoolManager.getInstance().executeGeneral(task);
+		}
+	}
+	
+	public String getCurrentEventName()
+	{
+		return _currentEventName;
+	}
+	
+	public String getNextEventInfo()
+	{
+		return _nextEventInfo;
+	}
+	
+	class GameEventStartTask implements Runnable
+	{
+		private long _startTime;
+		public ScheduledFuture<?> nextRun;
+		
+		public GameEventStartTask(long startTime)
+		{
+			_startTime = startTime;
+		}
+		
+		public void setStartTime(long startTime)
+		{
+			_startTime = startTime;
+		}
+		
+		@Override
+		public void run()
+		{
+			int delay = (int) Math.round((_startTime - System.currentTimeMillis()) / 1000.0);
+			
+			if (delay > 0)
+			{
+				announce(delay);
+			}
+			
+			int nextMsg = 0;
+			if (delay > 3600)
+			{
+				nextMsg = delay - 3600;
+			}
+			else if (delay > 1800)
+			{
+				nextMsg = delay - 1800;
+			}
+			else if (delay > 900)
+			{
+				nextMsg = delay - 900;
+			}
+			else if (delay > 600)
+			{
+				nextMsg = delay - 600;
+			}
+			else if (delay > 300)
+			{
+				nextMsg = delay - 300;
+			}
+			else if (delay > 60)
+			{
+				nextMsg = delay - 60;
+			}
+			else if (delay > 5)
+			{
+				nextMsg = delay - 5;
+			}
+			else if (delay > 0)
+			{
+				nextMsg = delay;
+			}
+			else
+			{
+				if (getEvent().isInactive())
+				{
+					startRegistration();
+				}
+				else if (getEvent().isRegistrating())
+				{
+					startEvent();
+				}
+				else
+				{
+					endEvent();
+				}
+			}
+			
+			if (delay > 0)
+			{
+				nextRun = ThreadPoolManager.getInstance().scheduleGeneral(this, nextMsg * 1000);
+			}
+		}
+		
+		private void announce(long time)
+		{
+			if ((time >= 3600) && ((time % 3600) == 0))
+			{
+				if (getEvent().isRegistrating())
+				{
+					Announcements.getInstance().announceToAll(getEvent().getName() + " Event: " + (time / 60 / 60) + " hour(s) until registration is closed! Type .join to register!", true);
+				}
+				else if (getEvent().isRunning())
+				{
+					getEvent().sysMsgToAllParticipants(getEvent().getName() + " Event: " + (time / 60 / 60) + " hour(s) until event is finished!");
+				}
+			}
+			else if (time >= 60)
+			{
+				if (getEvent().isRegistrating())
+				{
+					Announcements.getInstance().announceToAll(getEvent().getName() + " Event: " + (time / 60) + " minute(s) until registration is closed! Type .join to register!", true);
+				}
+				else if (getEvent().isRunning())
+				{
+					getEvent().sysMsgToAllParticipants(getEvent().getName() + " Event: " + (time / 60) + " minute(s) until the event is finished!");
+				}
+			}
+			else
+			{
+				if (getEvent().isRegistrating())
+				{
+					Announcements.getInstance().announceToAll(getEvent().getName() + " Event: " + time + " second(s) until registration is closed! Type .join to register!", true);
+				}
+				else if (getEvent().isRunning())
+				{
+					getEvent().sysMsgToAllParticipants(getEvent().getName() + " Event: " + time + " second(s) until the event is finished!");
+				}
+			}
+		}
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/IndividualGameEventConfig.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/IndividualGameEventConfig.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/IndividualGameEventConfig.java	(working copy)
@@ -0,0 +1,27 @@
+/*
+ * 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.gameeventengine;
+
+/**
+ * @author nuLL
+ */
+public class IndividualGameEventConfig extends GameEventConfig
+{
+	public int[] EVENT_COORDINATES;
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/GameEventPlayer.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/GameEventPlayer.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/GameEventPlayer.java	(working copy)
@@ -0,0 +1,131 @@
+/*
+ * 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.gameeventengine;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+
+/**
+ * @author nuLL
+ */
+public class GameEventPlayer implements Comparable<GameEventPlayer>
+{
+	private L2PcInstance _player;
+	private short _kills;
+	private short _deaths;
+	private byte _credits;
+	private int _originalNameColor;
+	private int _originalTitleColor;
+	private int[] _originalCoordinates;
+	
+	public GameEventPlayer(L2PcInstance player, byte playerCredits)
+	{
+		_player = player;
+		_kills = 0;
+		_deaths = 0;
+		_credits = playerCredits;
+	}
+	
+	public L2PcInstance getPlayer()
+	{
+		return _player;
+	}
+	
+	public void setPlayer(L2PcInstance player)
+	{
+		this._player = player;
+	}
+	
+	public short getKills()
+	{
+		return _kills;
+	}
+	
+	public void increaseKills()
+	{
+		++_kills;
+	}
+	
+	public short getDeaths()
+	{
+		return _deaths;
+	}
+	
+	public byte getCredits()
+	{
+		return _credits;
+	}
+	
+	public void increaseDeaths()
+	{
+		++_deaths;
+	}
+	
+	public void decreaseCredits()
+	{
+		--_credits;
+	}
+	
+	public int getOriginalNameColor()
+	{
+		return _originalNameColor;
+	}
+	
+	public int getOriginalTitleColor()
+	{
+		return _originalTitleColor;
+	}
+	
+	public void setOriginalNameColor(int _originalNameColor)
+	{
+		this._originalNameColor = _originalNameColor;
+	}
+	
+	public void setOriginalTitleColor(int _originalTitleColor)
+	{
+		this._originalTitleColor = _originalTitleColor;
+	}
+	
+	public int[] getOriginalCoordinates()
+	{
+		return _originalCoordinates;
+	}
+	
+	public void setOriginalCoordinates(int[] _originalCoordinates)
+	{
+		this._originalCoordinates = _originalCoordinates;
+	}
+	
+	@Override
+	public int compareTo(GameEventPlayer anotherEventPlayer)
+	{
+		Integer c1 = Integer.valueOf(anotherEventPlayer.getKills() - this.getKills());
+		Integer c2 = Integer.valueOf(this.getDeaths() - anotherEventPlayer.getDeaths());
+		Integer c3 = this.getPlayer().getName().compareTo(anotherEventPlayer.getPlayer().getName());
+		
+		if (c1 == 0)
+		{
+			if (c2 == 0)
+			{
+				return c3;
+			}
+			return c2;
+		}
+		return c1;
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/GameEvent.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/GameEvent.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/GameEvent.java	(working copy)
@@ -0,0 +1,626 @@
+/*
+ * 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.gameeventengine;
+
+import java.util.Collection;
+import java.util.logging.Logger;
+
+import com.l2jserver.gameserver.datatables.ItemTable;
+import com.l2jserver.gameserver.datatables.SkillData;
+import com.l2jserver.gameserver.instancemanager.InstanceManager;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.model.actor.instance.L2DoorInstance;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.itemcontainer.PcInventory;
+import com.l2jserver.gameserver.model.items.instance.L2ItemInstance;
+import com.l2jserver.gameserver.model.olympiad.OlympiadManager;
+import com.l2jserver.gameserver.model.skills.Skill;
+import com.l2jserver.gameserver.network.MultiBoxProtection;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+import com.l2jserver.util.Rnd;
+
+/**
+ * @author nuLL
+ */
+public abstract class GameEvent
+{
+	private static final Logger _log = Logger.getLogger(GameEvent.class.getName());
+	
+	public enum EventState
+	{
+		INACTIVE,
+		REGISTER,
+		STARTED,
+		REWARDING
+	}
+	
+	private EventState _state = EventState.INACTIVE;
+	protected String eventName = "";
+	protected int eventInstance = 0;
+	protected MultiBoxProtection multiBoxProtection = new MultiBoxProtection();
+	
+	public abstract GameEventConfig getConfigs();
+	
+	public abstract void init();
+	
+	protected abstract String calculateRewards();
+	
+	protected abstract void teleportPlayersToArena();
+	
+	protected abstract void teleportPlayersBack();
+	
+	protected abstract void clear();
+	
+	public abstract boolean isParticipant(int eventPlayerObjectId);
+	
+	public abstract int getCountPlayers();
+	
+	public abstract boolean addParticipant(GameEventPlayer eventPlayer);
+	
+	public abstract boolean removeParticipant(L2PcInstance playerInstance);
+	
+	public abstract void sysMsgToAllParticipants(String message);
+	
+	public abstract void onKill(L2Character killerCharacter, L2PcInstance killedPlayerInstance);
+	
+	public abstract boolean onSkillUse(L2PcInstance caster, Skill skill);
+	
+	public abstract void onLogin(L2PcInstance playerInstance);
+	
+	public abstract boolean onAction(L2PcInstance playerInstance, int targetedPlayerObjectId);
+	
+	/**
+	 * Gets the Game Event state
+	 * @return EventState: _state
+	 */
+	public EventState getState()
+	{
+		synchronized (_state)
+		{
+			return _state;
+		}
+	}
+	
+	/**
+	 * Sets the Game Event state
+	 * @param state as EventState
+	 */
+	protected void setState(EventState state)
+	{
+		synchronized (_state)
+		{
+			_state = state;
+		}
+	}
+	
+	public String getName()
+	{
+		return eventName;
+	}
+	
+	public boolean isInactive()
+	{
+		return getState() == EventState.INACTIVE;
+	}
+	
+	public boolean isRunning()
+	{
+		return getState() == EventState.STARTED;
+	}
+	
+	public boolean isRegistrating()
+	{
+		return getState() == EventState.REGISTER;
+	}
+	
+	/**
+	 * Method called to check if a player can register at the event
+	 * @param player as L2PcInstance
+	 * @param first as Integer
+	 * @return boolean: true if the player can register, otherwise false
+	 */
+	protected boolean canRegister(L2PcInstance player, boolean first)
+	{
+		if (first && getConfigs().ALLOW_TAKE_ITEM)
+		{
+			if (player.getInventory().getInventoryItemCount(getConfigs().TAKE_ITEM_ID, -1) < getConfigs().TAKE_COUNT)
+			{
+				player.sendMessage("You don't have enough " + ItemTable.getInstance().getTemplate(getConfigs().TAKE_ITEM_ID).getName() + " to participate.");
+				return false;
+			}
+		}
+		if (first && !isRegistrating())
+		{
+			player.sendMessage("The registration process is not active.");
+			return false;
+		}
+		if (first && isParticipant(player.getObjectId()))
+		{
+			player.sendMessage("You are already registred.");
+			return false;
+		}
+		if (player.isTeleporting())
+		{
+			player.sendMessage("You are in a teleporting process.");
+			return false;
+		}
+		if (!player.isOnline())
+		{
+			player.sendMessage("You have to be online to register.");
+			return false;
+		}
+		if (player.isMounted())
+		{
+			player.sendMessage("Revoke your pet before register.");
+			return false;
+		}
+		if (player.isInDuel())
+		{
+			player.sendMessage("You must complete the duel before register.");
+			return false;
+		}
+		if (first && (player.getEvent() != null))
+		{
+			player.sendMessage("You are already registered in another event.");
+			return false;
+		}
+		if (player.isInOlympiadMode() || OlympiadManager.getInstance().isRegistered(player))
+		{
+			player.sendMessage("You are already registered in the Olympics.");
+			return false;
+		}
+		if (player.isInParty() && player.getParty().isInDimensionalRift())
+		{
+			player.sendMessage("You are already registered in another event.");
+			return false;
+		}
+		if (player.isCursedWeaponEquipped())
+		{
+			player.sendMessage("You can't register to the event with a cursed weapon.");
+			return false;
+		}
+		if (player.isDead())
+		{
+			player.sendMessage("You can't register while you are dead.");
+			return false;
+		}
+		if (player.getKarma() > 0)
+		{
+			player.sendMessage("PK's can't participate in the opening event.");
+			return false;
+		}
+		if ((player.getLevel() < getConfigs().MIN_LEVEL) || (player.getLevel() > getConfigs().MAX_LEVEL))
+		{
+			player.sendMessage("You are not eligible to participate in the opening event with this level.");
+			return false;
+		}
+		if (first && (getCountPlayers() >= getConfigs().MAX_PARTICIPANTS))
+		{
+			player.sendMessage("The opening event has reached the maximum number of participants.");
+			return false;
+		}
+		if (first && !getConfigs().ALLOW_MULTIPLE_BOXES && !multiBoxProtection.registerNewConnection(player.getObjectId(), player.getHWID()))
+		{
+			player.sendMessage("DualBox is not allowed in the opening event!");
+			return false;
+		}
+		
+		return true;
+	}
+	
+	/**
+	 * Method called to start the event registration process
+	 */
+	public void startRegistration()
+	{
+		setState(EventState.REGISTER);
+	}
+	
+	/**
+	 * Method called to register a player in the event
+	 * @param playerInstance as L2PcInstance
+	 * @return boolean: true if success, otherwise false
+	 */
+	public boolean register(L2PcInstance playerInstance)
+	{
+		if (playerInstance == null)
+		{
+			return false;
+		}
+		
+		if (!canRegister(playerInstance, true))
+		{
+			return false;
+		}
+		
+		GameEventPlayer eventPlayer = new GameEventPlayer(playerInstance, getConfigs().PLAYER_CREDITS);
+		
+		if (getConfigs().ALLOW_TAKE_ITEM)
+		{
+			if (playerInstance.destroyItemByItemId("Event Participation Fee", getConfigs().TAKE_ITEM_ID, getConfigs().TAKE_COUNT, null, true))
+			{
+				if (addParticipant(eventPlayer))
+				{
+					return true;
+				}
+			}
+		}
+		
+		if (addParticipant(eventPlayer))
+		{
+			return true;
+		}
+		
+		return false;
+	}
+	
+	/**
+	 * Method called to remove the player registration in the event
+	 * @param playerInstance as L2PcInstance
+	 * @return boolean: true if success, otherwise false
+	 */
+	public boolean unRegister(L2PcInstance playerInstance)
+	{
+		if (playerInstance == null)
+		{
+			return false;
+		}
+		
+		if ((getState() == EventState.STARTED) || !isParticipant(playerInstance.getObjectId()))
+		{
+			playerInstance.sendMessage("You can't cancel your registration to the event at this moment!");
+			return false;
+		}
+		
+		if (removeParticipant(playerInstance))
+		{
+			playerInstance.sendMessage("Your registration at the " + eventName + " Event was cancelled!");
+			return true;
+		}
+		
+		return false;
+	}
+	
+	/**
+	 * Method called to start the event
+	 * @return boolean: true if success, otherwise false
+	 */
+	public boolean start()
+	{
+		if (getCountPlayers() >= getConfigs().MIN_PARTICIPANTS)
+		{
+			createInstance();
+			setState(EventState.STARTED);
+			closeDoors();
+			teleportPlayersToArena();
+			return true;
+		}
+		clear();
+		setState(EventState.INACTIVE);
+		return false;
+	}
+	
+	/**
+	 * Method called to stop the running event
+	 */
+	public void stop()
+	{
+		openDoors();
+		teleportPlayersBack();
+		clear();
+		setState(EventState.INACTIVE);
+	}
+	
+	/**
+	 * Method that return the event instance location
+	 * @return Integer eventInstance
+	 */
+	public int getEventInstance()
+	{
+		return eventInstance;
+	}
+	
+	/**
+	 * Method used to close the instance door(s)
+	 */
+	protected void closeDoors()
+	{
+		Collection<L2DoorInstance> doorsToClose = InstanceManager.getInstance().getInstance(eventInstance).getDoors();
+		
+		for (L2DoorInstance door : doorsToClose)
+		{
+			if (door != null)
+			{
+				door.closeMe();
+			}
+		}
+	}
+	
+	/**
+	 * Method used to open the instance door(s)
+	 */
+	private void openDoors()
+	{
+		Collection<L2DoorInstance> doorsToOpen = InstanceManager.getInstance().getInstance(eventInstance).getDoors();
+		
+		for (L2DoorInstance door : doorsToOpen)
+		{
+			if (door != null)
+			{
+				door.openMe();
+			}
+		}
+	}
+	
+	/**
+	 * Method called to create the event instance location
+	 */
+	protected void createInstance()
+	{
+		try
+		{
+			eventInstance = InstanceManager.getInstance().createDynamicInstance(getConfigs().INSTANCE_FILE);
+			InstanceManager.getInstance().getInstance(eventInstance).setAllowSummon(false);
+			InstanceManager.getInstance().getInstance(eventInstance).setPvPInstance(true);
+			InstanceManager.getInstance().getInstance(eventInstance).setEmptyDestroyTime((getConfigs().TELEPORT_TIME * 1000) + 60000L);
+		}
+		catch (Exception e)
+		{
+			eventInstance = 0;
+			_log.warning(eventName + " Event: Could not create the Event Instance Location!");
+		}
+	}
+	
+	/**
+	 * Method called to put the kill rewards into the players inventory
+	 * @param playerInstance as L2PcInstance
+	 */
+	protected void giveKillBonus(L2PcInstance playerInstance)
+	{
+		SystemMessage systemMessage = null;
+		PcInventory inv = playerInstance.getInventory();
+		if (ItemTable.getInstance().createDummyItem(getConfigs().TAKE_ITEM_ID).isStackable())
+		{
+			inv.addItem(eventName, getConfigs().TAKE_ITEM_ID, getConfigs().TAKE_COUNT, playerInstance, playerInstance);
+			
+			if (getConfigs().TAKE_COUNT > 1)
+			{
+				systemMessage = SystemMessage.getSystemMessage(SystemMessageId.EARNED_S2_S1_S);
+				systemMessage.addItemName(getConfigs().TAKE_ITEM_ID);
+				systemMessage.addLong(getConfigs().TAKE_COUNT);
+			}
+			else
+			{
+				systemMessage = SystemMessage.getSystemMessage(SystemMessageId.EARNED_ITEM_S1);
+				systemMessage.addItemName(getConfigs().TAKE_ITEM_ID);
+			}
+			
+			playerInstance.sendPacket(systemMessage);
+		}
+		else
+		{
+			for (int i = 0; i < getConfigs().TAKE_COUNT; ++i)
+			{
+				inv.addItem(eventName, getConfigs().TAKE_ITEM_ID, 1, playerInstance, playerInstance);
+				systemMessage = SystemMessage.getSystemMessage(SystemMessageId.EARNED_ITEM_S1);
+				systemMessage.addItemName(getConfigs().TAKE_ITEM_ID);
+				playerInstance.sendPacket(systemMessage);
+			}
+		}
+	}
+	
+	/**
+	 * Method called to put the rewards into the players inventory
+	 * @param playerInstance as L2PcInstance
+	 * @param rewards as Integer
+	 */
+	protected void deliverRewards(L2PcInstance playerInstance, int[][] rewards)
+	{
+		SystemMessage systemMessage = null;
+		
+		for (int[] reward : rewards)
+		{
+			PcInventory inv = playerInstance.getInventory();
+			if (ItemTable.getInstance().createDummyItem(reward[0]).isStackable())
+			{
+				inv.addItem(eventName, reward[0], reward[1], playerInstance, playerInstance);
+				
+				if (reward[1] > 1)
+				{
+					systemMessage = SystemMessage.getSystemMessage(SystemMessageId.EARNED_S2_S1_S);
+					systemMessage.addItemName(reward[0]);
+					systemMessage.addLong(reward[1]);
+				}
+				else
+				{
+					systemMessage = SystemMessage.getSystemMessage(SystemMessageId.EARNED_ITEM_S1);
+					systemMessage.addItemName(reward[0]);
+				}
+				
+				playerInstance.sendPacket(systemMessage);
+			}
+			else
+			{
+				for (int i = 0; i < reward[1]; ++i)
+				{
+					inv.addItem(eventName, reward[0], 1, playerInstance, playerInstance);
+					systemMessage = SystemMessage.getSystemMessage(SystemMessageId.EARNED_ITEM_S1);
+					systemMessage.addItemName(reward[0]);
+					playerInstance.sendPacket(systemMessage);
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Method called on Appearing packet received (player finished teleporting)<br>
+	 * Buff player's with event buffs
+	 * @param playerInstance
+	 */
+	public void onTeleported(L2PcInstance playerInstance)
+	{
+		if (!isRunning() || (playerInstance == null) || !isParticipant(playerInstance.getObjectId()))
+		{
+			return;
+		}
+		
+		if (playerInstance.isMageClass())
+		{
+			if ((getConfigs().LIST_MAGE_SUPPORT != null) && (getConfigs().LIST_MAGE_SUPPORT.length != 0))
+			{
+				for (Integer skillId : getConfigs().LIST_MAGE_SUPPORT)
+				{
+					int skillLevel = SkillData.getInstance().getMaxLevel(skillId);
+					Skill skill = SkillData.getInstance().getSkill(skillId, skillLevel);
+					if (skill != null)
+					{
+						skill.applyEffects(playerInstance, playerInstance);
+					}
+				}
+			}
+		}
+		else
+		{
+			if ((getConfigs().LIST_FIGHTER_SUPPORT != null) && (getConfigs().LIST_FIGHTER_SUPPORT.length != 0))
+			{
+				for (Integer skillId : getConfigs().LIST_FIGHTER_SUPPORT)
+				{
+					int skillLevel = SkillData.getInstance().getMaxLevel(skillId);
+					Skill skill = SkillData.getInstance().getSkill(skillId, skillLevel);
+					if (skill != null)
+					{
+						skill.applyEffects(playerInstance, playerInstance);
+					}
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Called when a player logs out
+	 * @param playerInstance as L2PcInstance
+	 */
+	public void onLogout(L2PcInstance playerInstance)
+	{
+		if ((playerInstance != null) && (isRunning() || isRegistrating()))
+		{
+			if (removeParticipant(playerInstance))
+			{
+				playerInstance.setXYZInvisible((83447 + Rnd.get(101)) - 50, (148638 + Rnd.get(101)) - 50, -3400); // Giran
+			}
+		}
+	}
+	
+	/**
+	 * Method called on every summon item use
+	 * @param eventPlayerObjectId as Integer
+	 * @return boolean: true if player is allowed to summon by item, otherwise false
+	 */
+	public boolean onItemSummon(int eventPlayerObjectId)
+	{
+		if (isRunning() && isParticipant(eventPlayerObjectId) && !getConfigs().ALLOW_SUMMON_BY_ITEM)
+		{
+			return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * Method called on every Scroll use
+	 * @param eventPlayerObjectId as Integer
+	 * @return boolean: true if player is allowed to use scroll, otherwise false
+	 */
+	public boolean onScrollUse(int eventPlayerObjectId)
+	{
+		if (isRunning() && isParticipant(eventPlayerObjectId) && !getConfigs().ALLOW_SCROLLS)
+		{
+			return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * Method called on every Potion use
+	 * @param eventPlayerObjectId as Integer
+	 * @return boolean: true if player is allowed to use potion, otherwise false
+	 */
+	public boolean onPotionUse(int eventPlayerObjectId)
+	{
+		if (isRunning() && isParticipant(eventPlayerObjectId) && !getConfigs().ALLOW_POTIONS)
+		{
+			return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * Method called on every Escape use
+	 * @param eventPlayerObjectId as Integer
+	 * @return boolean: true if player is allowed to use escape, otherwise false
+	 */
+	public boolean onEscapeUse(int eventPlayerObjectId)
+	{
+		if (isRunning() && isParticipant(eventPlayerObjectId))
+		{
+			return false;
+		}
+		return true;
+	}
+	
+	/**
+	 * Method called on every Item use
+	 * @param actor as L2PcInstance
+	 * @param item as L2ItemInstance
+	 * @return boolean: true if the player is allowed to use the item, otherwise false
+	 */
+	public boolean onItemUse(L2PcInstance actor, L2ItemInstance item)
+	{
+		if (!isRunning() || !isParticipant(actor.getObjectId()))
+		{
+			return true;
+		}
+		
+		if ((getConfigs().RESTRICT_ITEMS != null) && (getConfigs().RESTRICT_ITEMS.length != 0))
+		{
+			for (int itemId : getConfigs().RESTRICT_ITEMS)
+			{
+				if (item.getId() == itemId)
+				{
+					return false;
+				}
+			}
+		}
+		
+		return true;
+	}
+	
+	/**
+	 * Method called when a player talks with an event npc
+	 * @param player as L2PcInstance
+	 * @param npc as L2Npc
+	 * @return boolean: true if implemented by the event, otherwise false
+	 */
+	public boolean talkWithNpc(L2PcInstance player, L2Npc npc)
+	{
+		return false;
+	}
+	
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/tvt/TvTConfig.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/tvt/TvTConfig.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/tvt/TvTConfig.java	(working copy)
@@ -0,0 +1,277 @@
+/*
+ * 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.gameeventengine.tvt;
+
+import java.io.File;
+import java.util.logging.Logger;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+import com.l2jserver.gameserver.model.gameeventengine.IGameEventConfig;
+import com.l2jserver.gameserver.model.gameeventengine.TeamGameEventConfig;
+
+/**
+ * @author nuLL
+ */
+public class TvTConfig extends TeamGameEventConfig implements IGameEventConfig
+{
+	protected static final Logger _log = Logger.getLogger(TvTConfig.class.getName());
+	
+	/* TODO: IMPLEMENT */
+	public byte NUMBER_OF_ROUNDS = 0;
+	/* ------------------------------ */
+	
+	private static TvTConfig _instance;
+	
+	private TvTConfig()
+	{
+		load();
+	}
+	
+	public static TvTConfig getInstance()
+	{
+		if (_instance == null)
+		{
+			_instance = new TvTConfig();
+		}
+		return _instance;
+	}
+	
+	@Override
+	public void load()
+	{
+		try
+		{
+			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+			factory.setValidating(false);
+			factory.setIgnoringComments(true);
+			
+			File file = new File("./config/events/TvT.xml");
+			
+			Document doc = factory.newDocumentBuilder().parse(file);
+			
+			for (Node n = doc.getFirstChild(); n != null; n = n.getNextSibling())
+			{
+				
+				if (!"tvt".equalsIgnoreCase(n.getNodeName()))
+				{
+					continue;
+				}
+				
+				NamedNodeMap attrs = n.getAttributes();
+				
+				for (Node cd = n.getFirstChild(); cd != null; cd = cd.getNextSibling())
+				{
+					if ("InstanceFile".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						INSTANCE_FILE = attrs.getNamedItem("val").getNodeValue();
+					}
+					else if ("EventTimeInterval".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						EVENT_INTERVAL = attrs.getNamedItem("val").getNodeValue().split(",");
+					}
+					else if ("Duration".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						EVENT_DURATION_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("Participants".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_PARTICIPANTS = Short.parseShort(attrs.getNamedItem("min").getNodeValue());
+						MAX_PARTICIPANTS = Short.parseShort(attrs.getNamedItem("max").getNodeValue());
+					}
+					else if ("Level".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_LEVEL = Byte.parseByte(attrs.getNamedItem("min").getNodeValue());
+						MAX_LEVEL = Byte.parseByte(attrs.getNamedItem("max").getNodeValue());
+					}
+					else if ("TimeToRegistration".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REGISTRATION_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("TimeToTeleport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						TELEPORT_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowTakeItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_TAKE_ITEM = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("TakeItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						TAKE_ITEM_ID = Short.parseShort(attrs.getNamedItem("id").getNodeValue());
+						TAKE_COUNT = Integer.parseInt(attrs.getNamedItem("count").getNodeValue());
+					}
+					else if ("AllowKillBonus".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_KILL_BONUS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("KillReward".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						KILL_BONUS_ID = Short.parseShort(attrs.getNamedItem("id").getNodeValue());
+						KILL_BONUS_COUNT = Integer.parseInt(attrs.getNamedItem("count").getNodeValue());
+					}
+					else if ("StopAllEffects".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						STOP_ALL_EFFECTS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("HidePlayersIdentity".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						HIDE_PLAYERS_IDENTITY = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowMultipleBoxes".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_MULTIPLE_BOXES = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("Team".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						byte teamId = Byte.parseByte(attrs.getNamedItem("id").getNodeValue());
+						String name = attrs.getNamedItem("name").getNodeValue();
+						int color = Integer.decode("0x" + attrs.getNamedItem("color").getNodeValue());
+						String[] coord = attrs.getNamedItem("coordinates").getNodeValue().split(",");
+						int[] coordinates = new int[4];
+						for (int i = 0; i < coord.length; i++)
+						{
+							coordinates[i] = Integer.parseInt(coord[i]);
+						}
+						TEAMS.add(new GameEventTeamConfig(teamId, name, color, coordinates));
+					}
+					else if ("Rewards".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] itemIds = attrs.getNamedItem("id").getNodeValue().split(",");
+						String[] counts = attrs.getNamedItem("count").getNodeValue().split(",");
+						REWARDS = new int[itemIds.length][];
+						for (int i = 0; i < itemIds.length; i++)
+						{
+							REWARDS[i] = new int[]
+							{
+								Integer.parseInt(itemIds[i]),
+								Integer.parseInt(counts[i])
+							};
+						}
+					}
+					else if ("RewardTeamTie".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REWARD_EVENT_TIE = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("ListMageSupport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						LIST_MAGE_SUPPORT = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							LIST_MAGE_SUPPORT[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("ListFighterSupport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						LIST_FIGHTER_SUPPORT = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							LIST_FIGHTER_SUPPORT[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("RestrictItems".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] items = attrs.getNamedItem("val").getNodeValue().split(",");
+						RESTRICT_ITEMS = new int[items.length];
+						for (int i = 0; i < items.length; i++)
+						{
+							RESTRICT_ITEMS[i] = Integer.parseInt(items[i]);
+						}
+						
+					}
+					else if ("RestrictSkills".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						RESTRICT_SKILLS = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							RESTRICT_SKILLS[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("AllowPotions".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_POTIONS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowScrolls".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_SCROLLS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowSummonByItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_SUMMON_BY_ITEM = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowTargetTeamMembers".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_TARGET_TEAM_MEMBERS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("RequireMinFragsToReward".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REQUIRE_MIN_FRAGS_TO_REWARD = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("MinFragsRequired".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_FRAGS_TO_REWARD = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("NumberOfRounds".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						NUMBER_OF_ROUNDS = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+				}
+			}
+		}
+		catch (Exception e)
+		{
+			_log.warning("Error parsing TvT.xml, by error: " + e.getMessage());
+		}
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/lms/LMSEvent.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/lms/LMSEvent.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/lms/LMSEvent.java	(working copy)
@@ -0,0 +1,208 @@
+/*
+ * 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.gameeventengine.lms;
+
+import java.util.TreeSet;
+
+import javolution.util.FastMap;
+
+import com.l2jserver.gameserver.Announcements;
+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.model.gameeventengine.GameEventManager;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventPlayer;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventTeleporter;
+import com.l2jserver.gameserver.model.gameeventengine.IndividualGameEvent;
+import com.l2jserver.gameserver.network.clientpackets.Say2;
+import com.l2jserver.gameserver.network.serverpackets.CreatureSay;
+
+/**
+ * @author nuLL
+ */
+public final class LMSEvent extends IndividualGameEvent
+{
+	private static LMSEvent _instance;
+	
+	public LMSEvent()
+	{
+		_instance = this;
+	}
+	
+	public static LMSEvent getInstance()
+	{
+		if (_instance == null)
+		{
+			_instance = new LMSEvent();
+		}
+		return _instance;
+	}
+	
+	@Override
+	public LMSConfig getConfigs()
+	{
+		return LMSConfig.getInstance();
+	}
+	
+	@Override
+	public void init()
+	{
+		eventName = "Last Man Standing";
+		
+		participantPlayers = new FastMap<Integer, GameEventPlayer>().shared();
+		
+		setState(EventState.INACTIVE);
+		
+		GameEventManager.getInstance().registerEvent(getInstance());
+	}
+	
+	/**
+	 * Method called to set the winners
+	 * @return String: msg
+	 */
+	@Override
+	public String calculateRewards()
+	{
+		TreeSet<GameEventPlayer> players = new TreeSet<>();
+		players.addAll(participantPlayers.values());
+		
+		if (!getConfigs().REWARD_EVENT_TIE && (getCountPlayers() > 1))
+		{
+			return "Ended, thanks to everyone who participated!\nWe did not have winners!";
+		}
+		
+		for (int i = 0; i < players.size(); i++)
+		{
+			GameEventPlayer player = players.first();
+			
+			if ((player.getCredits() == 0) || (player.getKills() == 0))
+			{
+				break;
+			}
+			
+			if (getConfigs().REWARDS != null)
+			{
+				deliverRewards(player.getPlayer(), getConfigs().REWARDS);
+			}
+			
+			players.remove(player);
+			
+			Announcements.getInstance().announceToAll(eventName + " Event: Winner", true);
+			Announcements.getInstance().announceToAll(eventName + " Event: " + player.getPlayer().getName() + " won the event", true);
+			Announcements.getInstance().announceToAll(eventName + " Event: Kills: " + player.getKills(), true);
+			Announcements.getInstance().announceToAll(eventName + " Event: Deaths: " + String.valueOf(getConfigs().PLAYER_CREDITS - player.getCredits()), true);
+			
+			if (!getConfigs().REWARD_EVENT_TIE)
+			{
+				break;
+			}
+		}
+		
+		setState(EventState.REWARDING);
+		
+		return "Ended, thanks to everyone who participated!";
+	}
+	
+	/**
+	 * Method called when a player is killed
+	 * @param killerCharacter as L2Character
+	 * @param killedPlayerInstance as L2PcInstance
+	 */
+	@Override
+	public void onKill(L2Character killerCharacter, L2PcInstance killedPlayerInstance)
+	{
+		if ((killedPlayerInstance == null) || !isRunning())
+		{
+			return;
+		}
+		
+		if (!isParticipant(killedPlayerInstance.getObjectId()))
+		{
+			return;
+		}
+		
+		GameEventPlayer killedEventPlayer = participantPlayers.get(killedPlayerInstance.getObjectId());
+		
+		if (killedEventPlayer.getCredits() <= 1)
+		{
+			new GameEventTeleporter(killedEventPlayer, killedEventPlayer.getOriginalCoordinates(), true);
+			removeParticipant(killedPlayerInstance);
+		}
+		else
+		{
+			killedEventPlayer.decreaseCredits();
+			new GameEventTeleporter(killedEventPlayer, getConfigs().EVENT_COORDINATES, false);
+		}
+		
+		if (killerCharacter == null)
+		{
+			return;
+		}
+		
+		L2PcInstance killerPlayerInstance = null;
+		
+		if (killerCharacter.isSummon())
+		{
+			killerPlayerInstance = ((L2Summon) killerCharacter).getOwner();
+			
+			if (killerPlayerInstance == null)
+			{
+				return;
+			}
+		}
+		else if (killerCharacter.isPlayer())
+		{
+			killerPlayerInstance = (L2PcInstance) killerCharacter;
+		}
+		else
+		{
+			return;
+		}
+		
+		if (isParticipant(killerPlayerInstance.getObjectId()))
+		{
+			GameEventPlayer killerEventPlayer = participantPlayers.get(killerPlayerInstance.getObjectId());
+			
+			killerEventPlayer.increaseKills();
+			killerPlayerInstance.sendPacket(new CreatureSay(killerPlayerInstance.getObjectId(), Say2.PARTYROOM_ALL, killerPlayerInstance.getName(), "I have killed " + killedPlayerInstance.getName() + "!"));
+			killedPlayerInstance.sendPacket(new CreatureSay(killerPlayerInstance.getObjectId(), Say2.PARTYROOM_ALL, killerPlayerInstance.getName(), "I killed you!"));
+			killerPlayerInstance.sendMessage("Your kills: " + killerEventPlayer.getKills());
+			killerPlayerInstance.sendMessage("Your deaths: " + killerEventPlayer.getDeaths());
+			
+			if (killedEventPlayer.getCredits() == 0)
+			{
+				killedPlayerInstance.sendMessage("You do not have any credits, leaving the event!");
+			}
+			else
+			{
+				killedPlayerInstance.sendMessage("Now you have " + String.valueOf(killedEventPlayer.getCredits()) + " credit(s)!");
+			}
+		}
+		
+		if (getCountPlayers() == 1)
+		{
+			GameEventManager.getInstance().skipDelay();
+		}
+		
+		if (getConfigs().ALLOW_KILL_BONUS)
+		{
+			giveKillBonus(killerPlayerInstance);
+		}
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/tvt/TvTEvent.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/tvt/TvTEvent.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/tvt/TvTEvent.java	(working copy)
@@ -0,0 +1,169 @@
+/*
+ * 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.gameeventengine.tvt;
+
+import java.util.List;
+
+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.model.gameeventengine.GameEventManager;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventPlayer;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventTeam;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventTeleporter;
+import com.l2jserver.gameserver.model.gameeventengine.TeamGameEvent;
+import com.l2jserver.gameserver.model.gameeventengine.TeamGameEventConfig.GameEventTeamConfig;
+import com.l2jserver.gameserver.network.clientpackets.Say2;
+import com.l2jserver.gameserver.network.serverpackets.CreatureSay;
+
+/**
+ * @author nuLL
+ */
+public final class TvTEvent extends TeamGameEvent
+{
+	private static TvTEvent _instance;
+	
+	public TvTEvent()
+	{
+		_instance = this;
+	}
+	
+	public static TvTEvent getInstance()
+	{
+		if (_instance == null)
+		{
+			_instance = new TvTEvent();
+		}
+		return _instance;
+	}
+	
+	@Override
+	public TvTConfig getConfigs()
+	{
+		return TvTConfig.getInstance();
+	}
+	
+	@Override
+	public void init()
+	{
+		eventName = "Team vs Team";
+		
+		List<GameEventTeamConfig> teamsConfig = getConfigs().TEAMS;
+		teams = new GameEventTeam[teamsConfig.size()];
+		for (int i = 0; i < teamsConfig.size(); i++)
+		{
+			teams[i] = new GameEventTeam(teamsConfig.get(i).getId(), teamsConfig.get(i).getName(), teamsConfig.get(i).getColor(), teamsConfig.get(i).getCoordinates());
+		}
+		
+		setState(EventState.INACTIVE);
+		
+		GameEventManager.getInstance().registerEvent(getInstance());
+	}
+	
+	/**
+	 * Method called when a player is killed
+	 * @param killerCharacter as L2Character
+	 * @param killedPlayerInstance as L2PcInstance
+	 */
+	@Override
+	public void onKill(L2Character killerCharacter, L2PcInstance killedPlayerInstance)
+	{
+		if ((killedPlayerInstance == null) || !isRunning())
+		{
+			return;
+		}
+		
+		GameEventTeam killedTeam = getParticipantTeam(killedPlayerInstance.getObjectId());
+		
+		if (killedTeam == null)
+		{
+			return;
+		}
+		
+		GameEventPlayer killedEventPlayer = killedTeam.getEventPlayer(killedPlayerInstance.getObjectId());
+		
+		if (killedEventPlayer == null)
+		{
+			return;
+		}
+		
+		new GameEventTeleporter(killedEventPlayer, killedTeam.getCoordinates(), false);
+		
+		if (killerCharacter == null)
+		{
+			return;
+		}
+		
+		L2PcInstance killerPlayerInstance = null;
+		
+		if (killerCharacter.isSummon())
+		{
+			killerPlayerInstance = ((L2Summon) killerCharacter).getOwner();
+			
+			if (killerPlayerInstance == null)
+			{
+				return;
+			}
+		}
+		else if (killerCharacter.isPlayer())
+		{
+			killerPlayerInstance = (L2PcInstance) killerCharacter;
+		}
+		else
+		{
+			return;
+		}
+		
+		GameEventTeam killerTeam = getParticipantTeam(killerPlayerInstance.getObjectId());
+		
+		if (killerTeam == null)
+		{
+			return;
+		}
+		
+		GameEventPlayer killerEventPlayer = killerTeam.getEventPlayer(killerPlayerInstance.getObjectId());
+		
+		if (killerEventPlayer == null)
+		{
+			return;
+		}
+		
+		if (killerTeam.getId() != killedTeam.getId())
+		{
+			killedEventPlayer.increaseDeaths();
+			killedEventPlayer.increaseKills();
+			killerTeam.increasePoints();
+			
+			CreatureSay cs = new CreatureSay(killerPlayerInstance.getObjectId(), Say2.PARTYROOM_ALL, killerPlayerInstance.getName(), "I have killed " + killedPlayerInstance.getName() + "!");
+			
+			for (GameEventPlayer eventPlayer : killerTeam.getParticipatedPlayers().values())
+			{
+				if ((eventPlayer != null) && (eventPlayer.getPlayer() != null))
+				{
+					eventPlayer.getPlayer().sendPacket(cs);
+				}
+			}
+		}
+		
+		if (getConfigs().ALLOW_KILL_BONUS)
+		{
+			giveKillBonus(killerPlayerInstance);
+		}
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/TeamGameEventConfig.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/TeamGameEventConfig.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/TeamGameEventConfig.java	(working copy)
@@ -0,0 +1,67 @@
+/*
+ * 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.gameeventengine;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * @author nuLL
+ */
+public abstract class TeamGameEventConfig extends GameEventConfig
+{
+	public List<GameEventTeamConfig> TEAMS = new ArrayList<>();
+	public boolean ALLOW_TARGET_TEAM_MEMBERS = false;
+	
+	public class GameEventTeamConfig
+	{
+		private final byte id;
+		private final String name;
+		private final int color;
+		private final int[] coordinates;
+		
+		public GameEventTeamConfig(byte id, String name, int color, int[] coordinates)
+		{
+			this.id = id;
+			this.name = name;
+			this.color = color;
+			this.coordinates = coordinates;
+		}
+		
+		public byte getId()
+		{
+			return id;
+		}
+		
+		public String getName()
+		{
+			return name;
+		}
+		
+		public int getColor()
+		{
+			return color;
+		}
+		
+		public int[] getCoordinates()
+		{
+			return coordinates;
+		}
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/TeamGameEvent.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/TeamGameEvent.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/TeamGameEvent.java	(working copy)
@@ -0,0 +1,434 @@
+/*
+ * 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.gameeventengine;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.skills.Skill;
+import com.l2jserver.gameserver.network.clientpackets.Say2;
+import com.l2jserver.gameserver.network.serverpackets.CreatureSay;
+
+/**
+ * @author nuLL
+ */
+public abstract class TeamGameEvent extends GameEvent
+{
+	protected GameEventTeam[] teams;
+	protected short rounds = 1;
+	
+	@Override
+	public abstract TeamGameEventConfig getConfigs();
+	
+	/**
+	 * Method called to verify if a player is participant at the event
+	 * @param eventPlayerObjectId as Integer
+	 * @return boolean: true if the player is participant, otherwise false
+	 */
+	@Override
+	public boolean isParticipant(int eventPlayerObjectId)
+	{
+		boolean isParticipant = false;
+		for (GameEventTeam team : teams)
+		{
+			if (team.containsPlayer(eventPlayerObjectId))
+			{
+				isParticipant = true;
+			}
+		}
+		return isParticipant;
+	}
+	
+	/**
+	 * Method that returns the total of the event players
+	 * @return Integer playersCount
+	 */
+	@Override
+	public int getCountPlayers()
+	{
+		int playersCount = 0;
+		
+		for (GameEventTeam team : teams)
+		{
+			playersCount += team.getParticipatedPlayerCount();
+		}
+		
+		return playersCount;
+	}
+	
+	/**
+	 * Method that returns a list of the event teams
+	 * @return GameEventTeam[]: teams
+	 */
+	public GameEventTeam[] getTeams()
+	{
+		return teams;
+	}
+	
+	/**
+	 * Method that returns the team id with less players
+	 * @return GameEventTeam team
+	 */
+	private GameEventTeam getTeamWithMinPlayers()
+	{
+		GameEventTeam teamWithMinPlayers = null;
+		int playersCount = getConfigs().MAX_PARTICIPANTS;
+		
+		for (GameEventTeam team : teams)
+		{
+			if (playersCount > team.getParticipatedPlayerCount())
+			{
+				playersCount = team.getParticipatedPlayerCount();
+				teamWithMinPlayers = team;
+			}
+		}
+		return teamWithMinPlayers;
+	}
+	
+	/**
+	 * Method used to retrieve the Team of the event player
+	 * @param eventPlayerObjectId as Integer
+	 * @return GameEventTeam participantTeam
+	 */
+	public GameEventTeam getParticipantTeam(int eventPlayerObjectId)
+	{
+		GameEventTeam participantTeam = null;
+		
+		for (GameEventTeam team : teams)
+		{
+			if (team.containsPlayer(eventPlayerObjectId))
+			{
+				participantTeam = team;
+			}
+		}
+		
+		return participantTeam;
+	}
+	
+	/**
+	 * Add a GameEvent player to a team
+	 * @param eventPlayer as GameEventPlayer
+	 * @return boolean: true if success, otherwise false
+	 */
+	@Override
+	public boolean addParticipant(GameEventPlayer eventPlayer)
+	{
+		if (getTeamWithMinPlayers().addPlayer(eventPlayer))
+		{
+			eventPlayer.getPlayer().setEvent(this);
+			return true;
+		}
+		return false;
+	}
+	
+	/**
+	 * Removes a GameEvent player from it's team
+	 * @param playerInstance as L2PcInstance
+	 * @return boolean: true if success, otherwise false
+	 */
+	@Override
+	public boolean removeParticipant(L2PcInstance playerInstance)
+	{
+		GameEventTeam playerTeam = getParticipantTeam(playerInstance.getObjectId());
+		
+		if (playerTeam != null)
+		{
+			if (!getConfigs().ALLOW_MULTIPLE_BOXES)
+			{
+				multiBoxProtection.removeConnection(playerInstance.getObjectId());
+			}
+			
+			playerTeam.removePlayer(playerInstance.getObjectId());
+			playerInstance.setEvent(null);
+			
+			return true;
+		}
+		
+		return false;
+	}
+	
+	/**
+	 * Method called to teleport players to the arena
+	 */
+	@Override
+	public void teleportPlayersToArena()
+	{
+		for (GameEventTeam team : teams)
+		{
+			for (GameEventPlayer eventPlayer : team.getParticipatedPlayers().values())
+			{
+				if ((eventPlayer != null) && (eventPlayer.getPlayer() != null))
+				{
+					int[] playerCoordinates = new int[]
+					{
+						eventPlayer.getPlayer().getLocation().getX(),
+						eventPlayer.getPlayer().getLocation().getY(),
+						eventPlayer.getPlayer().getLocation().getZ(),
+						eventPlayer.getPlayer().getLocation().getHeading()
+					};
+					eventPlayer.setOriginalCoordinates(playerCoordinates);
+					eventPlayer.getPlayer().setCanRevive(false);
+					new GameEventTeleporter(eventPlayer, team.getCoordinates(), false);
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Method called to teleport players back
+	 */
+	@Override
+	public void teleportPlayersBack()
+	{
+		for (GameEventTeam team : teams)
+		{
+			for (GameEventPlayer eventPlayer : team.getParticipatedPlayers().values())
+			{
+				if ((eventPlayer != null) && (eventPlayer.getPlayer() != null))
+				{
+					new GameEventTeleporter(eventPlayer, eventPlayer.getOriginalCoordinates(), false);
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Method called to set the winner teams
+	 * @return String: msg
+	 */
+	@Override
+	public String calculateRewards()
+	{
+		List<GameEventTeam> winners = new ArrayList<>(getConfigs().TEAMS.size());
+		GameEventTeam winnerTeam = null;
+		short maxPoints = 0;
+		String msg = "";
+		
+		for (GameEventTeam team : teams)
+		{
+			if ((maxPoints == 0) && (team.getPoints() > 0))
+			{
+				maxPoints = team.getPoints();
+				winnerTeam = team;
+			}
+			else if ((team.getPoints() == maxPoints) && (team.getPoints() > 0))
+			{
+				maxPoints = team.getPoints();
+				winners.add(team);
+				winners.add(winnerTeam);
+				winnerTeam = null;
+			}
+			else if ((team.getPoints() > maxPoints))
+			{
+				maxPoints = team.getPoints();
+				winnerTeam = team;
+				winners.clear();
+			}
+		}
+		
+		setState(EventState.REWARDING);
+		
+		if (winnerTeam != null)
+		{
+			reward(winnerTeam);
+			msg = eventName + ": Event finish. Team " + winnerTeam.getName() + " won with " + winnerTeam.getPoints() + " kills.";
+		}
+		else if (winners.size() >= 2)
+		{
+			if (getConfigs().REWARD_EVENT_TIE)
+			{
+				for (GameEventTeam team : winners)
+				{
+					reward(team);
+				}
+			}
+			msg = eventName + ": Event has ended with both teams tying!";
+		}
+		else if (winners.isEmpty())
+		{
+			msg = eventName + ": Event has ended with both teams tying without any points!";
+		}
+		
+		winners.clear();
+		
+		return msg;
+	}
+	
+	/**
+	 * Method used to reward the winner team(s)
+	 * @param team as GameEventTeam
+	 */
+	public void reward(GameEventTeam team)
+	{
+		for (GameEventPlayer eventPlayer : team.getParticipatedPlayers().values())
+		{
+			if (eventPlayer == null)
+			{
+				continue;
+			}
+			
+			L2PcInstance playerInstance = eventPlayer.getPlayer();
+			
+			if (playerInstance == null)
+			{
+				continue;
+			}
+			
+			if (getConfigs().REQUIRE_MIN_FRAGS_TO_REWARD && (eventPlayer.getKills() < getConfigs().MIN_FRAGS_TO_REWARD))
+			{
+				playerInstance.sendMessage("You did not killed enough players at the event to receive the reward!");
+				continue;
+			}
+			
+			if (getConfigs().REWARDS != null)
+			{
+				deliverRewards(playerInstance, getConfigs().REWARDS);
+			}
+		}
+	}
+	
+	/**
+	 * Method used to send messages to all the event participants
+	 * @param message as String
+	 */
+	@Override
+	public void sysMsgToAllParticipants(String message)
+	{
+		for (GameEventTeam team : teams)
+		{
+			for (GameEventPlayer eventPlayer : team.getParticipatedPlayers().values())
+			{
+				if ((eventPlayer != null) && (eventPlayer.getPlayer() != null))
+				{
+					CreatureSay cs = new CreatureSay(0, Say2.CRITICAL_ANNOUNCE, eventName, message);
+					eventPlayer.getPlayer().sendPacket(cs);
+				}
+			}
+		}
+	}
+	
+	/**
+	 * Method called on every Skill use
+	 * @param caster as L2PcInstance
+	 * @param skill as L2Skill
+	 * @return boolean: true if the player is allowed to use the skill, otherwise false
+	 */
+	@Override
+	public boolean onSkillUse(L2PcInstance caster, Skill skill)
+	{
+		if (!isRunning() || !isParticipant(caster.getObjectId()))
+		{
+			return true;
+		}
+		
+		if ((getConfigs().RESTRICT_SKILLS != null) && (getConfigs().RESTRICT_SKILLS.length != 0))
+		{
+			for (int skillId : getConfigs().RESTRICT_SKILLS)
+			{
+				if (skillId == skill.getId())
+				{
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+	
+	/**
+	 * Method called on every onAction in L2PcIstance
+	 * @param playerInstance as L2PcInstance
+	 * @param targetedPlayerObjectId as Integer
+	 * @return boolean: true if player is allowed to target, otherwise false
+	 */
+	@Override
+	public boolean onAction(L2PcInstance playerInstance, int targetedPlayerObjectId)
+	{
+		if ((playerInstance == null) || !isRunning())
+		{
+			return true;
+		}
+		
+		if (playerInstance.isGM())
+		{
+			return true;
+		}
+		
+		GameEventTeam playerTeam = getParticipantTeam(playerInstance.getObjectId());
+		GameEventTeam targetedPlayerTeam = getParticipantTeam(targetedPlayerObjectId);
+		
+		if (((playerTeam != null) && (targetedPlayerTeam == null)) || ((playerTeam == null) && (targetedPlayerTeam != null)))
+		{
+			return false;
+		}
+		
+		if ((playerTeam != null) && (targetedPlayerTeam != null) && (playerTeam == targetedPlayerTeam) && (playerInstance.getObjectId() != targetedPlayerObjectId) && !getConfigs().ALLOW_TARGET_TEAM_MEMBERS)
+		{
+			return false;
+		}
+		
+		return true;
+	}
+	
+	/**
+	 * Method called when a player logs in
+	 * @param playerInstance as L2PcInstance
+	 */
+	@Override
+	public void onLogin(L2PcInstance playerInstance)
+	{
+		if ((playerInstance == null) || (!isRunning()))
+		{
+			return;
+		}
+		
+		GameEventTeam team = getParticipantTeam(playerInstance.getObjectId());
+		
+		if (team == null)
+		{
+			return;
+		}
+		
+		GameEventPlayer eventPlayer = team.getEventPlayer(playerInstance.getObjectId());
+		
+		if (eventPlayer == null)
+		{
+			return;
+		}
+		
+		new GameEventTeleporter(eventPlayer, team.getCoordinates(), true);
+	}
+	
+	/**
+	 * Method called to clear event attributes
+	 */
+	@Override
+	protected void clear()
+	{
+		for (GameEventTeam team : teams)
+		{
+			team.cleanMe();
+		}
+		
+		if (!getConfigs().ALLOW_MULTIPLE_BOXES)
+		{
+			multiBoxProtection.clear();
+		}
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/lms/LMSConfig.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/lms/LMSConfig.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/lms/LMSConfig.java	(working copy)
@@ -0,0 +1,270 @@
+/*
+ * 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.gameeventengine.lms;
+
+import java.io.File;
+import java.util.logging.Logger;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+import com.l2jserver.gameserver.model.gameeventengine.IGameEventConfig;
+import com.l2jserver.gameserver.model.gameeventengine.IndividualGameEventConfig;
+
+/**
+ * @author nuLL
+ */
+public class LMSConfig extends IndividualGameEventConfig implements IGameEventConfig
+{
+	private static final Logger _log = Logger.getLogger(LMSConfig.class.getName());
+	
+	private static LMSConfig _instance;
+	
+	private LMSConfig()
+	{
+		load();
+	}
+	
+	public static LMSConfig getInstance()
+	{
+		if (_instance == null)
+		{
+			_instance = new LMSConfig();
+		}
+		return _instance;
+	}
+	
+	@Override
+	public void load()
+	{
+		try
+		{
+			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+			factory.setValidating(false);
+			factory.setIgnoringComments(true);
+			
+			File file = new File("./config/events/LastManStanding.xml");
+			
+			Document doc = factory.newDocumentBuilder().parse(file);
+			
+			for (Node n = doc.getFirstChild(); n != null; n = n.getNextSibling())
+			{
+				
+				if (!"lms".equalsIgnoreCase(n.getNodeName()))
+				{
+					continue;
+				}
+				
+				NamedNodeMap attrs = n.getAttributes();
+				
+				for (Node cd = n.getFirstChild(); cd != null; cd = cd.getNextSibling())
+				{
+					if ("InstanceFile".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						INSTANCE_FILE = attrs.getNamedItem("val").getNodeValue();
+					}
+					else if ("EventTimeInterval".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						EVENT_INTERVAL = attrs.getNamedItem("val").getNodeValue().split(",");
+					}
+					else if ("Duration".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						EVENT_DURATION_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("Participants".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_PARTICIPANTS = Short.parseShort(attrs.getNamedItem("min").getNodeValue());
+						MAX_PARTICIPANTS = Short.parseShort(attrs.getNamedItem("max").getNodeValue());
+					}
+					else if ("Level".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_LEVEL = Byte.parseByte(attrs.getNamedItem("min").getNodeValue());
+						MAX_LEVEL = Byte.parseByte(attrs.getNamedItem("max").getNodeValue());
+					}
+					else if ("TimeToRegistration".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REGISTRATION_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("TimeToTeleport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						TELEPORT_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowTakeItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_TAKE_ITEM = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("TakeItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						TAKE_ITEM_ID = Short.parseShort(attrs.getNamedItem("id").getNodeValue());
+						TAKE_COUNT = Integer.parseInt(attrs.getNamedItem("count").getNodeValue());
+					}
+					else if ("AllowKillBonus".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_KILL_BONUS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("KillReward".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						KILL_BONUS_ID = Short.parseShort(attrs.getNamedItem("id").getNodeValue());
+						KILL_BONUS_COUNT = Integer.parseInt(attrs.getNamedItem("count").getNodeValue());
+					}
+					else if ("PlayerEventCoordinates".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						int x = Integer.parseInt(attrs.getNamedItem("x").getNodeValue());
+						int y = Integer.parseInt(attrs.getNamedItem("y").getNodeValue());
+						int z = Integer.parseInt(attrs.getNamedItem("z").getNodeValue());
+						int h = Integer.parseInt(attrs.getNamedItem("h").getNodeValue());
+						EVENT_COORDINATES = new int[]
+						{
+							x,
+							y,
+							z,
+							h
+						};
+					}
+					else if ("StopAllEffects".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						STOP_ALL_EFFECTS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("HidePlayersIdentity".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						HIDE_PLAYERS_IDENTITY = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowMultipleBoxes".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_MULTIPLE_BOXES = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("Rewards".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] itemIds = attrs.getNamedItem("id").getNodeValue().split(",");
+						String[] counts = attrs.getNamedItem("count").getNodeValue().split(",");
+						REWARDS = new int[itemIds.length][];
+						for (int i = 0; i < itemIds.length; i++)
+						{
+							REWARDS[i] = new int[]
+							{
+								Integer.parseInt(itemIds[i]),
+								Integer.parseInt(counts[i])
+							};
+						}
+					}
+					else if ("RewardTie".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REWARD_EVENT_TIE = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("ListMageSupport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						LIST_MAGE_SUPPORT = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							LIST_MAGE_SUPPORT[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("ListFighterSupport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						LIST_FIGHTER_SUPPORT = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							LIST_FIGHTER_SUPPORT[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("RestrictItems".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] items = attrs.getNamedItem("val").getNodeValue().split(",");
+						RESTRICT_ITEMS = new int[items.length];
+						for (int i = 0; i < items.length; i++)
+						{
+							RESTRICT_ITEMS[i] = Integer.parseInt(items[i]);
+						}
+						
+					}
+					else if ("RestrictSkills".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						RESTRICT_SKILLS = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							RESTRICT_SKILLS[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("AllowPotions".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_POTIONS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowScrolls".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_SCROLLS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowSummonByItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_SUMMON_BY_ITEM = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("RequireMinFragsToReward".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REQUIRE_MIN_FRAGS_TO_REWARD = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("MinFragsRequired".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_FRAGS_TO_REWARD = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("PlayerCredits".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						PLAYER_CREDITS = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+				}
+			}
+		}
+		catch (Exception e)
+		{
+			_log.warning("Error parsing LastManStanding.xml, by error: " + e.getMessage());
+		}
+	}
+	
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/ctf/CtFConfig.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/ctf/CtFConfig.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/ctf/CtFConfig.java	(working copy)
@@ -0,0 +1,283 @@
+/*
+ * 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.gameeventengine.ctf;
+
+import java.io.File;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.logging.Logger;
+
+import javax.xml.parsers.DocumentBuilderFactory;
+
+import org.w3c.dom.Document;
+import org.w3c.dom.NamedNodeMap;
+import org.w3c.dom.Node;
+
+import com.l2jserver.gameserver.model.Location;
+import com.l2jserver.gameserver.model.gameeventengine.IGameEventConfig;
+import com.l2jserver.gameserver.model.gameeventengine.TeamGameEventConfig;
+
+/**
+ * @author nuLL
+ */
+public class CtFConfig extends TeamGameEventConfig implements IGameEventConfig
+{
+	protected static final Logger _log = Logger.getLogger(CtFConfig.class.getName());
+	
+	public Map<Integer, Location> FLAGS = new HashMap<>();
+	
+	private static CtFConfig _instance;
+	
+	private CtFConfig()
+	{
+		load();
+	}
+	
+	public static CtFConfig getInstance()
+	{
+		if (_instance == null)
+		{
+			_instance = new CtFConfig();
+		}
+		return _instance;
+	}
+	
+	@Override
+	public void load()
+	{
+		try
+		{
+			DocumentBuilderFactory factory = DocumentBuilderFactory.newInstance();
+			factory.setValidating(false);
+			factory.setIgnoringComments(true);
+			
+			File file = new File("./config/events/CtF.xml");
+			
+			Document doc = factory.newDocumentBuilder().parse(file);
+			
+			for (Node n = doc.getFirstChild(); n != null; n = n.getNextSibling())
+			{
+				if (!"ctf".equalsIgnoreCase(n.getNodeName()))
+				{
+					continue;
+				}
+				
+				NamedNodeMap attrs = n.getAttributes();
+				
+				for (Node cd = n.getFirstChild(); cd != null; cd = cd.getNextSibling())
+				{
+					if ("InstanceFile".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						INSTANCE_FILE = attrs.getNamedItem("val").getNodeValue();
+					}
+					else if ("EventTimeInterval".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						EVENT_INTERVAL = attrs.getNamedItem("val").getNodeValue().split(",");
+					}
+					else if ("Duration".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						EVENT_DURATION_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("Participants".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_PARTICIPANTS = Short.parseShort(attrs.getNamedItem("min").getNodeValue());
+						MAX_PARTICIPANTS = Short.parseShort(attrs.getNamedItem("max").getNodeValue());
+					}
+					else if ("Level".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_LEVEL = Byte.parseByte(attrs.getNamedItem("min").getNodeValue());
+						MAX_LEVEL = Byte.parseByte(attrs.getNamedItem("max").getNodeValue());
+					}
+					else if ("TimeToRegistration".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REGISTRATION_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("TimeToTeleport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						TELEPORT_TIME = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowTakeItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_TAKE_ITEM = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("TakeItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						TAKE_ITEM_ID = Short.parseShort(attrs.getNamedItem("id").getNodeValue());
+						TAKE_COUNT = Integer.parseInt(attrs.getNamedItem("count").getNodeValue());
+					}
+					else if ("AllowKillBonus".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_KILL_BONUS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("KillReward".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						KILL_BONUS_ID = Short.parseShort(attrs.getNamedItem("id").getNodeValue());
+						KILL_BONUS_COUNT = Integer.parseInt(attrs.getNamedItem("count").getNodeValue());
+					}
+					else if ("StopAllEffects".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						STOP_ALL_EFFECTS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("HidePlayersIdentity".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						HIDE_PLAYERS_IDENTITY = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowMultipleBoxes".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_MULTIPLE_BOXES = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("Team".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						byte teamId = Byte.parseByte(attrs.getNamedItem("id").getNodeValue());
+						String name = attrs.getNamedItem("name").getNodeValue();
+						int color = Integer.decode("0x" + attrs.getNamedItem("color").getNodeValue());
+						String[] coord = attrs.getNamedItem("coordinates").getNodeValue().split(",");
+						int[] coordinates = new int[4];
+						for (int i = 0; i < coord.length; i++)
+						{
+							coordinates[i] = Integer.parseInt(coord[i]);
+						}
+						TEAMS.add(new GameEventTeamConfig(teamId, name, color, coordinates));
+					}
+					else if ("Flag".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						int teamId = Integer.parseInt(attrs.getNamedItem("teamId").getNodeValue());
+						int x = Integer.parseInt(attrs.getNamedItem("x").getNodeValue());
+						int y = Integer.parseInt(attrs.getNamedItem("y").getNodeValue());
+						int z = Integer.parseInt(attrs.getNamedItem("z").getNodeValue());
+						int h = Integer.parseInt(attrs.getNamedItem("h").getNodeValue());
+						Location loc = new Location(x, y, z, h);
+						FLAGS.put(teamId, loc);
+					}
+					else if ("Rewards".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] itemIds = attrs.getNamedItem("id").getNodeValue().split(",");
+						String[] counts = attrs.getNamedItem("count").getNodeValue().split(",");
+						REWARDS = new int[itemIds.length][];
+						for (int i = 0; i < itemIds.length; i++)
+						{
+							REWARDS[i] = new int[]
+							{
+								Integer.parseInt(itemIds[i]),
+								Integer.parseInt(counts[i])
+							};
+						}
+					}
+					else if ("RewardTeamTie".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REWARD_EVENT_TIE = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("ListMageSupport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						LIST_MAGE_SUPPORT = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							LIST_MAGE_SUPPORT[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("ListFighterSupport".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						LIST_FIGHTER_SUPPORT = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							LIST_FIGHTER_SUPPORT[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("RestrictItems".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] items = attrs.getNamedItem("val").getNodeValue().split(",");
+						RESTRICT_ITEMS = new int[items.length];
+						for (int i = 0; i < items.length; i++)
+						{
+							RESTRICT_ITEMS[i] = Integer.parseInt(items[i]);
+						}
+						
+					}
+					else if ("RestrictSkills".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						String[] skills = attrs.getNamedItem("val").getNodeValue().split(",");
+						RESTRICT_SKILLS = new int[skills.length];
+						for (int i = 0; i < skills.length; i++)
+						{
+							RESTRICT_SKILLS[i] = Integer.parseInt(skills[i]);
+						}
+					}
+					else if ("AllowPotions".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_POTIONS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowScrolls".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_SCROLLS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowSummonByItem".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_SUMMON_BY_ITEM = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("AllowTargetTeamMembers".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						ALLOW_TARGET_TEAM_MEMBERS = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("RequireMinFragsToReward".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						REQUIRE_MIN_FRAGS_TO_REWARD = Boolean.parseBoolean(attrs.getNamedItem("val").getNodeValue());
+					}
+					else if ("MinFragsRequired".equalsIgnoreCase(cd.getNodeName()))
+					{
+						attrs = cd.getAttributes();
+						MIN_FRAGS_TO_REWARD = Byte.parseByte(attrs.getNamedItem("val").getNodeValue());
+					}
+				}
+			}
+		}
+		catch (Exception e)
+		{
+			_log.warning("Error parsing CtF.xml, by error: " + e.getMessage());
+		}
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/IndividualGameEvent.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/IndividualGameEvent.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/IndividualGameEvent.java	(working copy)
@@ -0,0 +1,312 @@
+/*
+ * 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.gameeventengine;
+
+import java.util.Map;
+import java.util.TreeSet;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.skills.Skill;
+import com.l2jserver.gameserver.network.clientpackets.Say2;
+import com.l2jserver.gameserver.network.serverpackets.CreatureSay;
+
+/**
+ * @author nuLL
+ */
+public abstract class IndividualGameEvent extends GameEvent
+{
+	protected Map<Integer, GameEventPlayer> participantPlayers;
+	
+	@Override
+	public abstract IndividualGameEventConfig getConfigs();
+	
+	/**
+	 * Method called to verify if a player is participant at the event
+	 * @param eventPlayerObjectId as Integer
+	 * @return boolean: true if the player is participant, otherwise false
+	 */
+	@Override
+	public boolean isParticipant(int eventPlayerObjectId)
+	{
+		return participantPlayers.containsKey(eventPlayerObjectId);
+	}
+	
+	/**
+	 * Method that returns the total of the event players
+	 * @return Integer playersCount
+	 */
+	@Override
+	public int getCountPlayers()
+	{
+		return participantPlayers.size();
+	}
+	
+	/**
+	 * Add a GameEvent player to a team
+	 * @param eventPlayer as GameEventPlayer
+	 * @return boolean: true if success, otherwise false
+	 */
+	@Override
+	public boolean addParticipant(GameEventPlayer eventPlayer)
+	{
+		if (participantPlayers.containsKey(eventPlayer.getPlayer().getObjectId()))
+		{
+			return false;
+		}
+		
+		participantPlayers.put(eventPlayer.getPlayer().getObjectId(), eventPlayer);
+		eventPlayer.getPlayer().setEvent(this);
+		
+		return true;
+	}
+	
+	/**
+	 * Removes a GameEvent player from it's team
+	 * @param playerInstance as L2PcInstance
+	 * @return boolean: true if success, otherwise false
+	 */
+	@Override
+	public boolean removeParticipant(L2PcInstance playerInstance)
+	{
+		if (!participantPlayers.containsKey(playerInstance.getObjectId()))
+		{
+			return false;
+		}
+		
+		if (!getConfigs().ALLOW_MULTIPLE_BOXES)
+		{
+			multiBoxProtection.removeConnection(playerInstance.getObjectId());
+		}
+		
+		participantPlayers.remove(playerInstance.getObjectId());
+		playerInstance.setEvent(null);
+		
+		return true;
+	}
+	
+	/**
+	 * Method called to teleport players to the arena
+	 */
+	@Override
+	public void teleportPlayersToArena()
+	{
+		for (GameEventPlayer eventPlayer : participantPlayers.values())
+		{
+			if ((eventPlayer != null) && (eventPlayer.getPlayer() != null))
+			{
+				int[] playerCoordinates = new int[]
+				{
+					eventPlayer.getPlayer().getLocation().getX(),
+					eventPlayer.getPlayer().getLocation().getY(),
+					eventPlayer.getPlayer().getLocation().getZ(),
+					eventPlayer.getPlayer().getLocation().getHeading()
+				};
+				eventPlayer.setOriginalCoordinates(playerCoordinates);
+				new GameEventTeleporter(eventPlayer, getConfigs().EVENT_COORDINATES, false);
+			}
+		}
+	}
+	
+	/**
+	 * Method called to teleport players back
+	 */
+	@Override
+	public void teleportPlayersBack()
+	{
+		for (GameEventPlayer eventPlayer : participantPlayers.values())
+		{
+			if ((eventPlayer != null) && (eventPlayer.getPlayer() != null))
+			{
+				new GameEventTeleporter(eventPlayer, eventPlayer.getOriginalCoordinates(), false);
+			}
+		}
+	}
+	
+	/**
+	 * Method used to send messages to all the event participants
+	 * @param message as String
+	 */
+	@Override
+	public void sysMsgToAllParticipants(String message)
+	{
+		for (GameEventPlayer eventPlayer : participantPlayers.values())
+		{
+			if ((eventPlayer != null) && (eventPlayer.getPlayer() != null))
+			{
+				CreatureSay cs = new CreatureSay(0, Say2.CRITICAL_ANNOUNCE, eventName, message);
+				eventPlayer.getPlayer().sendPacket(cs);
+			}
+		}
+	}
+	
+	/**
+	 * Method called to get the informations about the 1st position player
+	 * @param countPos as Integer
+	 * @return String: player informations
+	 */
+	public String[] getFirstPosition(int countPos)
+	{
+		TreeSet<GameEventPlayer> players = new TreeSet<>();
+		players.addAll(participantPlayers.values());
+		
+		String text = "";
+		
+		for (int i = 0; i < countPos; i++)
+		{
+			if (players.isEmpty())
+			{
+				break;
+			}
+			
+			GameEventPlayer player = players.first();
+			
+			if (player.getKills() == 0)
+			{
+				break;
+			}
+			
+			text += player.getPlayer().getName() + "," + String.valueOf(player.getKills()) + ";";
+			players.remove(player);
+			
+			int playerPointPrev = player.getKills();
+			
+			if (!getConfigs().REWARD_EVENT_TIE)
+			{
+				continue;
+			}
+			
+			while (!players.isEmpty())
+			{
+				player = players.first();
+				if (player.getKills() != playerPointPrev)
+				{
+					break;
+				}
+				text += player.getPlayer().getName() + "," + String.valueOf(player.getKills()) + ";";
+				players.remove(player);
+			}
+		}
+		
+		if (text != "")
+		{
+			return text.split("\\;");
+		}
+		
+		return null;
+	}
+	
+	/**
+	 * Method called on every Skill use
+	 * @param caster as L2PcInstance
+	 * @param skill as L2Skill
+	 * @return boolean: true if the player is allowed to use the skill, otherwise false
+	 */
+	@Override
+	public boolean onSkillUse(L2PcInstance caster, Skill skill)
+	{
+		if (!isRunning() || !isParticipant(caster.getObjectId()))
+		{
+			return true;
+		}
+		
+		if ((getConfigs().RESTRICT_SKILLS != null) && (getConfigs().RESTRICT_SKILLS.length != 0))
+		{
+			for (int skillId : getConfigs().RESTRICT_SKILLS)
+			{
+				if (skillId == skill.getId())
+				{
+					return false;
+				}
+			}
+		}
+		
+		return true;
+	}
+	
+	/**
+	 * Method called on every onAction in L2PcIstance
+	 * @param playerInstance as L2PcInstance
+	 * @param targetedPlayerObjectId as Integer
+	 * @return boolean: true if player is allowed to target, otherwise false
+	 */
+	@Override
+	public boolean onAction(L2PcInstance playerInstance, int targetedPlayerObjectId)
+	{
+		if ((playerInstance == null) || !isRunning())
+		{
+			return true;
+		}
+		
+		if (playerInstance.isGM())
+		{
+			return true;
+		}
+		
+		if (!isParticipant(playerInstance.getObjectId()) && isParticipant(targetedPlayerObjectId))
+		{
+			return false;
+		}
+		
+		if (isParticipant(playerInstance.getObjectId()) && !isParticipant(targetedPlayerObjectId))
+		{
+			return false;
+		}
+		
+		return true;
+	}
+	
+	/**
+	 * Method called when a player logs in
+	 * @param playerInstance as L2PcInstance
+	 */
+	@Override
+	public void onLogin(L2PcInstance playerInstance)
+	{
+		if ((playerInstance == null) || (!isRunning()))
+		{
+			return;
+		}
+		
+		if (isParticipant(playerInstance.getObjectId()))
+		{
+			GameEventPlayer eventPlayer = participantPlayers.get(playerInstance.getObjectId());
+			
+			if (eventPlayer == null)
+			{
+				return;
+			}
+			
+			new GameEventTeleporter(eventPlayer, getConfigs().EVENT_COORDINATES, true);
+		}
+	}
+	
+	/**
+	 * Method called to clear event attributes
+	 */
+	@Override
+	protected void clear()
+	{
+		participantPlayers.clear();
+		
+		if (!getConfigs().ALLOW_MULTIPLE_BOXES)
+		{
+			multiBoxProtection.clear();
+		}
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/GameEventTeleporter.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/GameEventTeleporter.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/GameEventTeleporter.java	(working copy)
@@ -0,0 +1,194 @@
+/*
+ * 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.gameeventengine;
+
+import com.l2jserver.gameserver.ThreadPoolManager;
+import com.l2jserver.gameserver.enums.Team;
+import com.l2jserver.gameserver.instancemanager.ZoneManager;
+import com.l2jserver.gameserver.model.L2Party;
+import com.l2jserver.gameserver.model.actor.L2Summon;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.entity.Duel;
+import com.l2jserver.gameserver.model.zone.type.L2CustomZone;
+import com.l2jserver.util.Rnd;
+import com.l2jserver.util.Util;
+
+/**
+ * @author nuLL
+ */
+public class GameEventTeleporter implements Runnable
+{
+	private GameEventPlayer _eventPlayer = null;
+	private GameEvent _event = null;
+	private int[] _coordinates = new int[4];
+	
+	public GameEventTeleporter(GameEventPlayer eventPlayer, int[] coordinates, boolean fastSchedule)
+	{
+		_eventPlayer = eventPlayer;
+		_event = eventPlayer.getPlayer().getEvent();
+		_coordinates = coordinates;
+		
+		long delay = _event.getConfigs().TELEPORT_TIME * 1000;
+		
+		ThreadPoolManager.getInstance().scheduleGeneral(this, fastSchedule ? 0 : delay);
+	}
+	
+	@Override
+	public void run()
+	{
+		if ((_eventPlayer == null) || (_event == null))
+		{
+			return;
+		}
+		
+		L2PcInstance playerInstance = _eventPlayer.getPlayer();
+		
+		if (playerInstance == null)
+		{
+			return;
+		}
+		
+		L2Summon summon = playerInstance.getSummon();
+		
+		if (summon != null)
+		{
+			summon.unSummon(playerInstance);
+		}
+		
+		if (_event.getConfigs().STOP_ALL_EFFECTS == true)
+		{
+			playerInstance.stopAllEffectsExceptThoseThatLastThroughDeath();
+		}
+		
+		if (playerInstance.isInParty())
+		{
+			L2Party party = playerInstance.getParty();
+			party.removePartyMember(playerInstance, null);
+		}
+		
+		if (playerInstance.isInDuel())
+		{
+			playerInstance.setDuelState(Duel.DUELSTATE_INTERRUPTED);
+		}
+		
+		if (playerInstance.getInstanceId() != 0)
+		{
+			playerInstance.setInstanceId(0);
+		}
+		
+		if (_event.getEventInstance() != 0)
+		{
+			if (_event.isRunning())
+			{
+				playerInstance.setInstanceId(_event.getEventInstance());
+			}
+			else
+			{
+				playerInstance.setInstanceId(0);
+			}
+		}
+		
+		playerInstance.doRevive();
+		
+		L2CustomZone customZone = ZoneManager.getInstance().getCustomZone(_coordinates[0], _coordinates[1], _coordinates[2]);
+		if (customZone != null)
+		{
+			playerInstance.teleToCustomZone(_coordinates[0], _coordinates[1], _coordinates[2], true);
+		}
+		else
+		{
+			playerInstance.teleToLocation((_coordinates[0] + Rnd.get(101)) - 50, (_coordinates[1] + Rnd.get(101)) - 50, _coordinates[2], _coordinates[3]);
+		}
+		
+		if (_event.isRunning())
+		{
+			_eventPlayer.setOriginalNameColor(playerInstance.getAppearance().getNameColor());
+			_eventPlayer.setOriginalTitleColor(playerInstance.getAppearance().getTitleColor());
+			
+			if (_event instanceof TeamGameEvent)
+			{
+				TeamGameEvent teamGameEvent = (TeamGameEvent) _event;
+				
+				GameEventTeam team = teamGameEvent.getParticipantTeam(playerInstance.getObjectId());
+				
+				if (team != null)
+				{
+					if (teamGameEvent.getConfigs().TEAMS.size() <= 2)
+					{
+						playerInstance.setTeam(team.getId() == 1 ? Team.BLUE : Team.RED);
+					}
+					else
+					{
+						playerInstance.getAppearance().setNameColor(team.getColor());
+					}
+				}
+			}
+			else if (_event instanceof IndividualGameEvent)
+			{
+				playerInstance.setTeam(Team.BLUE);
+			}
+			
+			if (_event.getConfigs().HIDE_PLAYERS_IDENTITY)
+			{
+				playerInstance.getAppearance().setVisibleName(Util.hexToString(Util.generateHex(16)));
+				playerInstance.getAppearance().setVisibleTitle("L2 nuLL");
+				playerInstance.getAppearance().setTitleColor(Integer.decode("0x" + "333333"));
+			}
+			
+			playerInstance.setCanRevive(false);
+		}
+		else
+		{
+			if (_event instanceof TeamGameEvent)
+			{
+				TeamGameEvent teamGameEvent = (TeamGameEvent) _event;
+				
+				if (teamGameEvent.getConfigs().TEAMS.size() <= 2)
+				{
+					playerInstance.setTeam(Team.NONE);
+				}
+				else
+				{
+					playerInstance.getAppearance().setNameColor(_eventPlayer.getOriginalNameColor());
+				}
+			}
+			else if (_event instanceof IndividualGameEvent)
+			{
+				playerInstance.setTeam(Team.NONE);
+			}
+			
+			if (_event.getConfigs().HIDE_PLAYERS_IDENTITY)
+			{
+				playerInstance.getAppearance().setVisibleName(playerInstance.getName());
+				playerInstance.getAppearance().setVisibleTitle(playerInstance.getTitle());
+				playerInstance.getAppearance().setTitleColor(_eventPlayer.getOriginalTitleColor());
+			}
+			
+			playerInstance.setCanRevive(true);
+			playerInstance.setEvent(null);
+		}
+		
+		playerInstance.setCurrentCp(playerInstance.getMaxCp());
+		playerInstance.setCurrentHp(playerInstance.getMaxHp());
+		playerInstance.setCurrentMp(playerInstance.getMaxMp());
+		
+		playerInstance.broadcastStatusUpdate();
+		playerInstance.broadcastUserInfo();
+	}
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/dm/DMEvent.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/dm/DMEvent.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/dm/DMEvent.java	(working copy)
@@ -0,0 +1,259 @@
+/*
+ * 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.gameeventengine.dm;
+
+import java.util.TreeSet;
+
+import javolution.util.FastMap;
+
+import com.l2jserver.gameserver.Announcements;
+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.model.gameeventengine.GameEventManager;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventPlayer;
+import com.l2jserver.gameserver.model.gameeventengine.GameEventTeleporter;
+import com.l2jserver.gameserver.model.gameeventengine.IndividualGameEvent;
+import com.l2jserver.gameserver.network.clientpackets.Say2;
+import com.l2jserver.gameserver.network.serverpackets.CreatureSay;
+
+/**
+ * @author nuLL
+ */
+public final class DMEvent extends IndividualGameEvent
+{
+	private static DMEvent _instance;
+	
+	public DMEvent()
+	{
+		_instance = this;
+	}
+	
+	public static DMEvent getInstance()
+	{
+		if (_instance == null)
+		{
+			_instance = new DMEvent();
+		}
+		return _instance;
+	}
+	
+	@Override
+	public DMConfig getConfigs()
+	{
+		return DMConfig.getInstance();
+	}
+	
+	@Override
+	public void init()
+	{
+		eventName = "Death Match";
+		
+		participantPlayers = new FastMap<Integer, GameEventPlayer>().shared();
+		
+		setState(EventState.INACTIVE);
+		
+		GameEventManager.getInstance().registerEvent(getInstance());
+	}
+	
+	/**
+	 * Method called to set the winners
+	 * @return String: msg
+	 */
+	@Override
+	public String calculateRewards()
+	{
+		TreeSet<GameEventPlayer> players = new TreeSet<>();
+		players.addAll(participantPlayers.values());
+		
+		for (int i = 0; i < 3; i++)
+		{
+			if (players.isEmpty())
+			{
+				break;
+			}
+			
+			GameEventPlayer player = players.first();
+			
+			if (player.getKills() == 0)
+			{
+				break;
+			}
+			
+			reward(player, i + 1);
+			players.remove(player);
+			
+			int playerPointPrev = player.getKills();
+			
+			if (getConfigs().REWARD_EVENT_TIE)
+			{
+				continue;
+			}
+			
+			while (!players.isEmpty())
+			{
+				player = players.first();
+				
+				if (player.getKills() != playerPointPrev)
+				{
+					break;
+				}
+				
+				reward(player, i + 1);
+				players.remove(player);
+			}
+		}
+		
+		setState(EventState.REWARDING);
+		
+		String[] topPositions;
+		topPositions = getFirstPosition(3);
+		
+		if (topPositions != null)
+		{
+			Announcements.getInstance().announceToAll(eventName + " Event: Winners", true);
+			
+			for (String topPosition : topPositions)
+			{
+				String[] row = topPosition.split("\\,");
+				
+				Announcements.getInstance().announceToAll(eventName + " Event: " + row[0] + " with " + row[1] + " kills.", true);
+			}
+		}
+		else
+		{
+			Announcements.getInstance().announceToAll(eventName + " Event: No players win the match (nobody was killed).", true);
+		}
+		
+		return "Ended, thanks to everyone who participated!";
+	}
+	
+	private void reward(GameEventPlayer eventPlayer, int pos)
+	{
+		if (eventPlayer == null)
+		{
+			return;
+		}
+		
+		L2PcInstance playerInstance = eventPlayer.getPlayer();
+		
+		if (playerInstance == null)
+		{
+			return;
+		}
+		
+		int[][] rewards = null;
+		
+		if (pos == 1)
+		{
+			rewards = getConfigs().REWARDS_1ST_PLACE;
+		}
+		else if (pos == 2)
+		{
+			rewards = getConfigs().REWARDS_2ND_PLACE;
+		}
+		else if (pos == 3)
+		{
+			rewards = getConfigs().REWARDS_3RD_PLACE;
+		}
+		else
+		{
+			return;
+		}
+		
+		if (rewards != null)
+		{
+			deliverRewards(playerInstance, rewards);
+		}
+	}
+	
+	/**
+	 * Method called when a player is killed
+	 * @param killerCharacter as L2Character
+	 * @param killedPlayerInstance as L2PcInstance
+	 */
+	@Override
+	public void onKill(L2Character killerCharacter, L2PcInstance killedPlayerInstance)
+	{
+		if ((killedPlayerInstance == null) || !isRunning())
+		{
+			return;
+		}
+		
+		if (!isParticipant(killedPlayerInstance.getObjectId()))
+		{
+			return;
+		}
+		
+		GameEventPlayer killedEventPlayer = participantPlayers.get(killedPlayerInstance.getObjectId());
+		
+		if (killedEventPlayer == null)
+		{
+			return;
+		}
+		
+		new GameEventTeleporter(killedEventPlayer, getConfigs().EVENT_COORDINATES, false);
+		
+		if (killerCharacter == null)
+		{
+			return;
+		}
+		
+		L2PcInstance killerPlayerInstance = null;
+		
+		if (killerCharacter.isSummon())
+		{
+			killerPlayerInstance = ((L2Summon) killerCharacter).getOwner();
+			
+			if (killerPlayerInstance == null)
+			{
+				return;
+			}
+		}
+		else if (killerCharacter.isPlayer())
+		{
+			killerPlayerInstance = (L2PcInstance) killerCharacter;
+		}
+		else
+		{
+			return;
+		}
+		
+		if (isParticipant(killerPlayerInstance.getObjectId()))
+		{
+			GameEventPlayer killerEventPlayer = participantPlayers.get(killerPlayerInstance.getObjectId());
+			
+			killerEventPlayer.increaseKills();
+			killerPlayerInstance.sendPacket(new CreatureSay(killerPlayerInstance.getObjectId(), Say2.PARTYROOM_ALL, killerPlayerInstance.getName(), "I have killed " + killedPlayerInstance.getName() + "!"));
+			killerPlayerInstance.sendMessage("Your kills: " + killerEventPlayer.getKills());
+			killerPlayerInstance.sendMessage("Your deaths: " + killerEventPlayer.getDeaths());
+			
+			killedEventPlayer.increaseDeaths();
+			killedPlayerInstance.sendPacket(new CreatureSay(killerPlayerInstance.getObjectId(), Say2.PARTYROOM_ALL, killerPlayerInstance.getName(), "I killed you!"));
+			killedPlayerInstance.sendMessage("Your kills: " + killerEventPlayer.getKills());
+			killedPlayerInstance.sendMessage("Your deaths: " + killedEventPlayer.getDeaths());
+		}
+		
+		if (getConfigs().ALLOW_KILL_BONUS)
+		{
+			giveKillBonus(killerPlayerInstance);
+		}
+	}
+	
+}
Index: java/com/l2jserver/gameserver/model/gameeventengine/GameEventTeam.java
===================================================================
--- java/com/l2jserver/gameserver/model/gameeventengine/GameEventTeam.java	(revision 0)
+++ java/com/l2jserver/gameserver/model/gameeventengine/GameEventTeam.java	(working copy)
@@ -0,0 +1,119 @@
+/*
+ * 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.gameeventengine;
+
+import java.util.Map;
+
+import javolution.util.FastMap;
+
+/**
+ * @author nuLL
+ */
+public class GameEventTeam
+{
+	private final byte _id;
+	private final String _name;
+	private final int _color;
+	private final int[] _coordinates;
+	private short _points;
+	private final Map<Integer, GameEventPlayer> _participatedPlayers;
+	
+	public GameEventTeam(byte id, String name, int color, int[] coordinates)
+	{
+		_id = id;
+		_name = name;
+		_color = color;
+		_coordinates = coordinates;
+		_points = 0;
+		_participatedPlayers = new FastMap<Integer, GameEventPlayer>().shared();
+	}
+	
+	public boolean addPlayer(GameEventPlayer eventPlayer)
+	{
+		if (eventPlayer == null)
+		{
+			return false;
+		}
+		
+		_participatedPlayers.put(eventPlayer.getPlayer().getObjectId(), eventPlayer);
+		
+		return true;
+	}
+	
+	public void removePlayer(int eventPlayerObjectId)
+	{
+		_participatedPlayers.remove(eventPlayerObjectId);
+	}
+	
+	public void increasePoints()
+	{
+		++_points;
+	}
+	
+	public void cleanMe()
+	{
+		_participatedPlayers.clear();
+		_points = 0;
+	}
+	
+	public boolean containsPlayer(int eventPlayerObjectId)
+	{
+		return _participatedPlayers.containsKey(eventPlayerObjectId);
+	}
+	
+	public byte getId()
+	{
+		return _id;
+	}
+	
+	public String getName()
+	{
+		return _name;
+	}
+	
+	public int getColor()
+	{
+		return _color;
+	}
+	
+	public int[] getCoordinates()
+	{
+		return _coordinates;
+	}
+	
+	public short getPoints()
+	{
+		return _points;
+	}
+	
+	public Map<Integer, GameEventPlayer> getParticipatedPlayers()
+	{
+		return _participatedPlayers;
+	}
+	
+	public int getParticipatedPlayerCount()
+	{
+		return _participatedPlayers.size();
+	}
+	
+	public GameEventPlayer getEventPlayer(int eventPlayerObjectId)
+	{
+		return _participatedPlayers.get(eventPlayerObjectId);
+	}
+}