Creado para L2J-Server H5 BETA, creado por nuLL
### 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);
+ }
+}