Territory War System. DP change Required!

L2_GameServer/java/com/l2jserver/Config.java

@@ -62,6 +62,7 @@ public final class Config
 	public static final String RATES_CONFIG_FILE = "./config/rates.properties";
 	public static final String CONFIGURATION_FILE = "./config/server.properties";
 	public static final String SIEGE_CONFIGURATION_FILE = "./config/siege.properties";
+	public static final String TW_CONFIGURATION_FILE = "./config/territorywar.properties";
 	public static final String TELNET_FILE = "./config/telnet.properties";
 	public static final String FLOOD_PROTECTOR_FILE = "./config/floodprotector.properties";
 	public static final String MMO_CONFIG_FILE = "./config/mmo.properties";

L2_GameServer/java/com/l2jserver/gameserver/GameServer.java

@@ -105,6 +105,7 @@ import com.l2jserver.gameserver.instancemanager.QuestManager;
 import com.l2jserver.gameserver.instancemanager.RaidBossPointsManager;
 import com.l2jserver.gameserver.instancemanager.RaidBossSpawnManager;
 import com.l2jserver.gameserver.instancemanager.SiegeManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.instancemanager.TransformationManager;
 import com.l2jserver.gameserver.instancemanager.ZoneManager;
 import com.l2jserver.gameserver.model.AutoChatHandler;
@@ -262,6 +263,7 @@ public class GameServer
 		SiegeManager.getInstance().getSieges();
 		FortManager.getInstance().loadInstances();
 		FortSiegeManager.getInstance();
+		TerritoryWarManager.getInstance();
 		
 		TeleportLocationTable.getInstance();
 		LevelUpData.getInstance();

L2_GameServer/java/com/l2jserver/gameserver/SevenSigns.java

@@ -29,12 +29,15 @@ import com.l2jserver.L2DatabaseFactory;
 import com.l2jserver.gameserver.datatables.MapRegionTable;
 import com.l2jserver.gameserver.datatables.SkillTable;
 import com.l2jserver.gameserver.instancemanager.CastleManager;
+import com.l2jserver.gameserver.instancemanager.QuestManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.AutoChatHandler;
 import com.l2jserver.gameserver.model.AutoSpawnHandler;
 import com.l2jserver.gameserver.model.L2World;
 import com.l2jserver.gameserver.model.AutoSpawnHandler.AutoSpawnInstance;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.model.entity.Castle;
+import com.l2jserver.gameserver.model.quest.Quest;
 import com.l2jserver.gameserver.network.SystemMessageId;
 import com.l2jserver.gameserver.network.serverpackets.SSQInfo;
 import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
@@ -1462,6 +1465,11 @@ public class SevenSigns
 					// Send message that Seal Validation has begun.
 					sendMessageToAll(SystemMessageId.SEAL_VALIDATION_PERIOD_BEGUN);
 					
+					// Change next Territory War date
+					Quest twQuest = QuestManager.getInstance().getQuest(TerritoryWarManager.qn);
+					if (twQuest != null)
+						twQuest.startQuestTimer("setNextTWDate", 30000, null, null);
+					
 					_log.info("SevenSigns: The " + getCabalName(_previousWinner) + " have won the competition with " + getCurrentScore(_previousWinner) + " points!");
 					break;
 				case PERIOD_SEAL_VALIDATION: // Reset for New Cycle

L2_GameServer/java/com/l2jserver/gameserver/datatables/MapRegionTable.java

@@ -28,12 +28,14 @@ import com.l2jserver.gameserver.instancemanager.CastleManager;
 import com.l2jserver.gameserver.instancemanager.ClanHallManager;
 import com.l2jserver.gameserver.instancemanager.FortManager;
 import com.l2jserver.gameserver.instancemanager.InstanceManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.instancemanager.TownManager;
 import com.l2jserver.gameserver.instancemanager.ZoneManager;
 import com.l2jserver.gameserver.model.Location;
 import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.L2Npc;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.actor.instance.L2SiegeFlagInstance;
 import com.l2jserver.gameserver.model.entity.Castle;
 import com.l2jserver.gameserver.model.entity.ClanHall;
 import com.l2jserver.gameserver.model.entity.Fort;
@@ -412,7 +414,10 @@ public class MapRegionTable
 				{
 					castle = CastleManager.getInstance().getCastle(player);
 					fort = FortManager.getInstance().getFort(player);
-					if (castle != null)
+					L2SiegeFlagInstance tw_flag = TerritoryWarManager.getInstance().getFlagForClan(player.getClan());
+					if (tw_flag != null)
+						return new Location(tw_flag.getX(), tw_flag.getY(), tw_flag.getZ());
+					else if (castle != null)
 					{
 						if (castle.getSiege().getIsInProgress())
 						{

L2_GameServer/java/com/l2jserver/gameserver/datatables/SkillTable.java

@@ -127,21 +127,20 @@ public class SkillTable
 	/**
 	 * Returns an array with siege skills. If addNoble == true, will add also Advanced headquarters.
 	 */
-	public L2Skill[] getSiegeSkills(boolean addNoble)
+	public L2Skill[] getSiegeSkills(boolean addNoble, boolean hasCastle)
 	{
-		L2Skill[] temp = null;
-		
+		L2Skill[] temp = new L2Skill[2 + (addNoble ? 1 : 0) + (hasCastle ? 2 : 0)];
+		int i = 0;
+		temp[i++] = _skills.get(SkillTable.getSkillHashCode(246, 1));
+		temp[i++] = _skills.get(SkillTable.getSkillHashCode(247, 1));
+
 		if (addNoble)
+			temp[i++] = _skills.get(SkillTable.getSkillHashCode(326, 1));
+		if (hasCastle)
 		{
-			temp = new L2Skill[3];
-			temp[2] = _skills.get(SkillTable.getSkillHashCode(326, 1));
+			temp[i++] = _skills.get(SkillTable.getSkillHashCode(844, 1));
+			temp[i++] = _skills.get(SkillTable.getSkillHashCode(845, 1));
 		}
-		else
-			temp = new L2Skill[2];
-		
-		temp[0] = _skills.get(SkillTable.getSkillHashCode(246, 1));
-		temp[1] = _skills.get(SkillTable.getSkillHashCode(247, 1));
-		
 		return temp;
 	}
 	

L2_GameServer/java/com/l2jserver/gameserver/instancemanager/SiegeManager.java

@@ -78,7 +78,7 @@ public class SiegeManager
 	// Method - Public
 	public final void addSiegeSkills(L2PcInstance character)
 	{
-		for (L2Skill sk : SkillTable.getInstance().getSiegeSkills(character.isNoble()))
+		for (L2Skill sk : SkillTable.getInstance().getSiegeSkills(character.isNoble(), character.getClan().getHasCastle() > 0))
 		{
 			character.addSkill(sk, false);
 		}
@@ -162,7 +162,7 @@ public class SiegeManager
 	
 	public final void removeSiegeSkills(L2PcInstance character)
 	{
-		for (L2Skill sk : SkillTable.getInstance().getSiegeSkills(character.isNoble()))
+		for (L2Skill sk : SkillTable.getInstance().getSiegeSkills(character.isNoble(), character.getClan().getHasCastle() > 0))
 		{
 			character.removeSkill(sk);
 		}

L2_GameServer/java/com/l2jserver/gameserver/instancemanager/TerritoryWarManager.java

@@ -0,0 +1,1507 @@
+/*
+ * This program 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.
+ * 
+ * This program 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.instancemanager;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.InputStream;
+import java.sql.Connection;
+import java.sql.PreparedStatement;
+import java.sql.ResultSet;
+import java.util.Calendar;
+import java.util.Collection;
+import java.util.Map;
+import java.util.concurrent.ScheduledFuture;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+
+import com.l2jserver.Config;
+import com.l2jserver.L2DatabaseFactory;
+import com.l2jserver.gameserver.Announcements;
+import com.l2jserver.gameserver.ThreadPoolManager;
+import com.l2jserver.gameserver.datatables.ClanTable;
+import com.l2jserver.gameserver.datatables.NpcTable;
+import com.l2jserver.gameserver.datatables.ResidentialSkillTable;
+import com.l2jserver.gameserver.model.L2Clan;
+import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.L2Spawn;
+import com.l2jserver.gameserver.model.L2World;
+import com.l2jserver.gameserver.model.Location;
+import com.l2jserver.gameserver.model.TerritoryWard;
+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.actor.instance.L2SiegeFlagInstance;
+import com.l2jserver.gameserver.model.entity.Castle;
+import com.l2jserver.gameserver.model.entity.Fort;
+import com.l2jserver.gameserver.model.quest.Quest;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.CharInfo;
+import com.l2jserver.gameserver.network.serverpackets.ExBrExtraUserInfo;
+import com.l2jserver.gameserver.network.serverpackets.L2GameServerPacket;
+import com.l2jserver.gameserver.network.serverpackets.RelationChanged;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+import com.l2jserver.gameserver.network.serverpackets.UserInfo;
+import com.l2jserver.gameserver.templates.chars.L2NpcTemplate;
+import com.l2jserver.gameserver.util.Util;
+import com.l2jserver.util.L2Properties;
+
+import javolution.util.FastList;
+import javolution.util.FastMap;
+
+public class TerritoryWarManager
+{
+	private static final Logger _log = Logger.getLogger(TerritoryWarManager.class.getName());
+	
+	public static final TerritoryWarManager getInstance()
+	{
+		return SingletonHolder._instance;
+	}
+	
+	// =========================================================
+	// Data Field
+	public static String qn = "TerritoryWarSuperClass";
+	public static int DEFENDERMAXCLANS; // Max number of clans
+	public static int DEFENDERMAXPLAYERS; // Max number of individual player
+	public static int CLANMINLEVEL;
+	public static int PLAYERMINLEVEL;
+	public static int MINTWBADGEFORNOBLESS;
+	public static int MINTWBADGEFORSTRIDERS;
+	public static int MINTWBADGEFORBIGSTRIDER;
+	public static Long WARLENGTH;
+	public static boolean PLAYER_WITH_WARD_CAN_BE_KILLED_IN_PEACEZONE;
+	public final Map<Integer,Integer> TERRITORY_ITEM_IDS;
+	
+	// Territory War settings
+	private FastMap<Integer, FastList<L2Clan>> _registeredClans;
+	private FastMap<Integer, FastList<Integer>> _registeredMercenaries;
+	private FastMap<Integer, Territory> _territoryList;
+	private FastList<Integer> _disguisedPlayers;
+	private FastList<TerritoryWard> _territoryWards;
+	private FastMap<L2Clan, L2SiegeFlagInstance> _clanFlags;
+	private Map<Integer,Integer[]> _participantPoints = new FastMap<Integer,Integer[]>();
+	private Calendar _startTWDate = Calendar.getInstance();
+	private boolean _isRegistrationOver = true;
+	private boolean _isTWChannelOpen = false;
+	private boolean _isTWInProgress = false;
+	protected ScheduledFuture<?> _scheduledStartTWTask = null;
+	protected ScheduledFuture<?> _scheduledEndTWTask = null;
+	protected ScheduledFuture<?> _scheduledRewardOnlineTask = null;
+	
+	// =========================================================
+	// Constructor
+	private TerritoryWarManager()
+	{
+		_log.info("Initializing TerritoryWarManager");
+
+		// init lists
+		_registeredClans = new FastMap<Integer, FastList<L2Clan>>();
+		_registeredMercenaries = new FastMap<Integer, FastList<Integer>>();
+		_territoryList = new FastMap<Integer, Territory>();
+		_territoryWards = new FastList<TerritoryWard>();
+		_clanFlags = new FastMap<L2Clan, L2SiegeFlagInstance>();
+		_disguisedPlayers = new FastList<Integer>();
+		TERRITORY_ITEM_IDS = new FastMap<Integer,Integer>();
+
+		// Constant data
+		TERRITORY_ITEM_IDS.put(81, 13757);
+		TERRITORY_ITEM_IDS.put(82, 13758);
+		TERRITORY_ITEM_IDS.put(83, 13759);
+		TERRITORY_ITEM_IDS.put(84, 13760);
+		TERRITORY_ITEM_IDS.put(85, 13761);
+		TERRITORY_ITEM_IDS.put(86, 13762);
+		TERRITORY_ITEM_IDS.put(87, 13763);
+		TERRITORY_ITEM_IDS.put(88, 13764);
+		TERRITORY_ITEM_IDS.put(89, 13765);
+		// load data from database
+		load();
+	}
+	
+	// =========================================================
+	// Method - Public
+	public int getRegisteredTerritoryId(L2PcInstance player)
+	{
+		if (player == null || !_isTWChannelOpen || player.getLevel() < PLAYERMINLEVEL)
+			return 0;
+		if (player.getClan() != null)
+		{
+			if (player.getClan().getHasCastle() > 0)
+				return player.getClan().getHasCastle() + 80;
+			for(int cId:_registeredClans.keySet())
+				if (_registeredClans.get(cId).contains(player.getClan()))
+					return cId + 80;
+		}
+		for(int cId:_registeredMercenaries.keySet())
+			if (_registeredMercenaries.get(cId).contains(player.getObjectId()))
+				return cId + 80;
+		return 0;
+	}
+	
+	public boolean isAllyField(L2PcInstance player, int fieldId)
+	{
+		if (player == null || player.getSiegeSide() == 0)
+			return false;
+		else if ((player.getSiegeSide() - 80) == fieldId)
+			return true;
+		else if (fieldId > 100 && _territoryList.containsKey((player.getSiegeSide() - 80))
+				&& _territoryList.get((player.getSiegeSide() - 80)).getFortId() == fieldId)
+			return true;
+		return false;
+
+	}
+	
+	/**
+	 * Return true if the clan is registered<BR><BR>
+	 * @param clan The L2Clan of the player
+	 */
+	public final boolean checkIsRegistered(int castleId, L2Clan clan)
+	{
+		if (clan == null)
+			return false;
+		else if (clan.getHasCastle() > 0)
+			return (castleId == -1 ? true:(clan.getHasCastle() == castleId));
+		if (castleId == -1)
+		{
+			for(int cId:_registeredClans.keySet())
+				if (_registeredClans.get(cId).contains(clan))
+					return true;
+			return false;
+		}
+		else
+			return _registeredClans.get(castleId).contains(clan);
+	}
+	
+	/**
+	 * Return true if the player is registered<BR><BR>
+	 * @param integer The objectId of the player
+	 */
+	public final boolean checkIsRegistered(int castleId, int objId)
+	{
+		if (castleId == -1)
+		{
+			for(int cId:_registeredMercenaries.keySet())
+				if (_registeredMercenaries.get(cId).contains(objId))
+					return true;
+			return false;
+		}
+		else
+			return _registeredMercenaries.get(castleId).contains(objId);
+	}
+	
+	public Territory getTerritory(int castleId)
+	{
+		return _territoryList.get(castleId);
+	}
+	
+	public FastList<Territory> getAllTerritories()
+	{
+		FastList<Territory> ret = new FastList<Territory>();
+		for (Territory t : _territoryList.values())
+			if (t.getOwnerClan() != null)
+				ret.add(t);
+		return ret;
+	}
+	
+	public Collection<L2Clan> getRegisteredClans(int castleId)
+	{
+		return _registeredClans.get(castleId);
+	}
+	
+	public void addDisguisedPlayer(int playerObjId)
+	{
+		_disguisedPlayers.add(playerObjId);
+	}
+	
+	public boolean isDisguised(int playerObjId)
+	{
+		return _disguisedPlayers.contains(playerObjId);
+	}
+	
+	public Collection<Integer> getRegisteredMercenaries(int castleId)
+	{
+		return _registeredMercenaries.get(castleId);
+	}
+	
+	public long getTWStartTimeInMillis()
+	{
+		return _startTWDate.getTimeInMillis();
+	}
+	
+	public Calendar getTWStart()
+	{
+		return _startTWDate;
+	}
+	
+	public void setTWStartTimeInMillis(long time)
+	{
+		_startTWDate.setTimeInMillis(time);
+		if (_isTWInProgress)
+		{
+			if (_scheduledEndTWTask != null)
+				_scheduledEndTWTask.cancel(false);
+			_scheduledEndTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleEndTWTask(), 1000);
+		}
+		else
+		{
+			if (_scheduledStartTWTask != null)
+				_scheduledStartTWTask.cancel(false);
+			_scheduledStartTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartTWTask(), 1000);
+		}
+	}
+	
+	public boolean isTWChannelOpen()
+	{
+		return _isTWChannelOpen;
+	}
+	
+	public void registerClan(int castleId, L2Clan clan)
+	{
+		if (clan == null || (_registeredClans.get(castleId) != null && _registeredClans.get(castleId).contains(clan)))
+			return;
+		else if (_registeredClans.get(castleId) == null)
+			_registeredClans.put(castleId, new FastList<L2Clan>());
+		
+		_registeredClans.get(castleId).add(clan);
+		changeRegistration(castleId, clan.getClanId(), false);
+	}
+	
+	public void registerMerc(int castleId, L2PcInstance player)
+	{
+		if (player == null || player.getLevel() < PLAYERMINLEVEL
+				|| (_registeredMercenaries.get(castleId) != null && _registeredMercenaries.get(castleId).contains(player.getObjectId())))
+			return;
+		else if (_registeredMercenaries.get(castleId) == null)
+			_registeredMercenaries.put(castleId, new FastList<Integer>());
+		
+		_registeredMercenaries.get(castleId).add(player.getObjectId());
+		changeRegistration(castleId, player.getObjectId(), false);
+	}
+	
+	public void removeClan(int castleId, L2Clan clan)
+	{
+		if (clan == null)
+			return;
+		else if (_registeredClans.get(castleId) != null && _registeredClans.get(castleId).contains(clan))
+		{
+			_registeredClans.get(castleId).remove(clan);
+			changeRegistration(castleId, clan.getClanId(), true);
+		}
+	}
+
+	public void removeMerc(int castleId, L2PcInstance player)
+	{
+		if (player == null)
+			return;
+		else if (_registeredMercenaries.get(castleId) != null && _registeredMercenaries.get(castleId).contains(player.getObjectId()))
+		{
+			_registeredMercenaries.get(castleId).remove(_registeredMercenaries.get(castleId).indexOf(player.getObjectId()));
+			changeRegistration(castleId, player.getObjectId(), true);
+		}
+	}
+	
+	public boolean getIsRegistrationOver()
+	{
+		return _isRegistrationOver;
+	}
+	
+	public boolean isTWInProgress()
+	{
+		return _isTWInProgress;
+	}
+	
+	public void territoryCatapultDestroyed(int castleId)
+	{
+		if (_territoryList.get(castleId) != null)
+			_territoryList.get(castleId).changeNPCsSpawn(2, false);
+		for (L2DoorInstance door : CastleManager.getInstance().getCastleById(castleId).getDoors())
+			door.openMe();
+	}
+	
+	public L2Npc addTerritoryWard(int territoryId, int newOwnerId, int oldOwnerId)
+	{
+		L2Npc ret = null;
+		if (_territoryList.get(newOwnerId) != null)
+		{
+			Territory terNew = _territoryList.get(newOwnerId);
+			TerritoryNPCSpawn ward = terNew.getFreeWardSpawnPlace();
+			if (ward != null)
+			{
+				ward._npcId = territoryId;
+				ret = spawnNPC(36491 + territoryId, ward.getLocation());
+				if (!isTWInProgress())
+					ret.setIsInvul(true);
+				ward.setNPC(ret);
+				if (terNew.getOwnerClan() != null && terNew.getOwnedWardIds().contains(newOwnerId + 80))
+					for(int wardId : terNew.getOwnedWardIds())
+						if (ResidentialSkillTable.getInstance().getSkills(wardId) != null)
+							for (L2Skill sk : ResidentialSkillTable.getInstance().getSkills(wardId))
+								for (L2PcInstance member : terNew.getOwnerClan().getOnlineMembers(0))
+									if (!member.isInOlympiadMode())
+										member.addSkill(sk, false);
+			}
+			if (_territoryList.containsKey(oldOwnerId))
+			{
+				Territory terOld = _territoryList.get(oldOwnerId);
+				terOld.removeWard(territoryId);
+				updateTerritoryData(terOld);
+				updateTerritoryData(terNew);
+				SystemMessage sm = new SystemMessage(SystemMessageId.CLAN_S1_HAS_SUCCEDED_IN_CAPTURING_S2_TERRITORY_WARD);
+				sm.addString(terNew.getOwnerClan().getName());
+				sm.addString(ward.getNpc().getName().replaceAll(" Ward", ""));
+				announceToParticipants(sm, 135000, 13500);
+				if (terOld.getOwnerClan() != null)
+				{
+					if (ResidentialSkillTable.getInstance().getSkills(territoryId) != null)
+						for (L2Skill sk : ResidentialSkillTable.getInstance().getSkills(territoryId))
+							for (L2PcInstance member : terOld.getOwnerClan().getOnlineMembers(0))
+								member.removeSkill(sk, false);
+					if (!terOld.getOwnedWardIds().isEmpty() && !terOld.getOwnedWardIds().contains(oldOwnerId + 80))
+						for(int wardId : terOld.getOwnedWardIds())
+							if (ResidentialSkillTable.getInstance().getSkills(wardId) != null)
+								for (L2Skill sk : ResidentialSkillTable.getInstance().getSkills(wardId))
+									for (L2PcInstance member : terOld.getOwnerClan().getOnlineMembers(0))
+										member.removeSkill(sk, false);
+				}
+			}
+		}
+		else
+			_log.warning("TerritoryWarManager: Missing territory for new Ward owner: " + newOwnerId + ";" + territoryId);
+		return ret;
+	}
+	
+	public L2SiegeFlagInstance getHQForClan(L2Clan clan)
+	{
+		if (clan.getHasCastle() > 0)
+			return _territoryList.get(clan.getHasCastle()).getHQ();
+		return null;
+	}
+	
+	public L2SiegeFlagInstance getHQForTerritory(int territoryId)
+	{
+		if (_territoryList.containsKey(territoryId - 80))
+			return _territoryList.get(territoryId - 80).getHQ();
+		return null;
+	}
+	
+	public void setHQForClan(L2Clan clan, L2SiegeFlagInstance hq)
+	{
+		if (clan.getHasCastle() > 0)
+			_territoryList.get(clan.getHasCastle()).setHQ(hq);
+	}
+	
+	public void addClanFlag(L2Clan clan, L2SiegeFlagInstance flag)
+	{
+		_clanFlags.put(clan, flag);
+	}
+	
+	public boolean isClanHasFlag(L2Clan clan)
+	{
+		return _clanFlags.containsKey(clan);
+	}
+	
+	public L2SiegeFlagInstance getFlagForClan(L2Clan clan)
+	{
+		if (_clanFlags.containsKey(clan))
+			return _clanFlags.get(clan);
+		return null;
+	}
+	
+	public void removeClanFlag(L2Clan clan)
+	{
+		_clanFlags.remove(clan);
+	}
+	
+	public FastList<TerritoryWard> getAllTerritoryWards()
+	{
+		return _territoryWards;
+	}
+	
+	public TerritoryWard getTerritoryWardForOwner(int castleId)
+	{
+		for(TerritoryWard twWard : _territoryWards)
+			if (twWard.getTerritoryId() == castleId)
+				return twWard;
+		return null;
+	}
+	
+	public TerritoryWard getTerritoryWard(int territoryId)
+	{
+		for(TerritoryWard twWard : _territoryWards)
+			if (twWard.getTerritoryId() == territoryId)
+				return twWard;
+		return null;
+	}
+	
+	public TerritoryWard getTerritoryWard(L2PcInstance player)
+	{
+		for(TerritoryWard twWard : _territoryWards)
+			if (twWard.playerId == player.getObjectId())
+				return twWard;
+		return null;
+	}
+	
+	public void dropCombatFlag(L2PcInstance player, boolean isKilled)
+	{
+		for(TerritoryWard twWard : _territoryWards)
+			if (twWard.playerId == player.getObjectId())
+			{
+				twWard.dropIt();
+				if (isTWInProgress())
+					twWard.spawnMe();
+				if (isKilled)
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.THE_CHAR_THAT_ACQUIRED_S1_WARD_HAS_BEEN_KILLED);
+					sm.addString(twWard.itemInstance.getName().replaceAll(" Ward", ""));
+					announceToParticipants(sm, 0, 0);
+				}
+			}
+	}
+	
+	public void giveTWQuestPoint(L2PcInstance player)
+	{
+		if (!_participantPoints.containsKey(player.getObjectId()))
+			_participantPoints.put(player.getObjectId(), new Integer[]{player.getSiegeSide(),0,0,0,0,0,0});
+		_participantPoints.get(player.getObjectId())[2]++;
+	}
+	
+	public void giveTWPoint(L2PcInstance killer, int victimSide, int type)
+	{
+		if (victimSide == 0)
+			return;
+		if (killer.getParty() != null && type < 5)
+			for(L2PcInstance pl : killer.getParty().getPartyMembers())
+			{
+				if (pl.getSiegeSide() == victimSide || pl.getSiegeSide() == 0 || !Util.checkIfInRange(2000, killer, pl, false))
+					continue;
+				else if (!_participantPoints.containsKey(pl.getObjectId()))
+					_participantPoints.put(pl.getObjectId(), new Integer[]{pl.getSiegeSide(),0,0,0,0,0,0});
+				_participantPoints.get(pl.getObjectId())[type]++;
+			}
+		else
+		{
+			if (killer.getSiegeSide() == victimSide || killer.getSiegeSide() == 0)
+				return;
+			else if (!_participantPoints.containsKey(killer.getObjectId()))
+				_participantPoints.put(killer.getObjectId(), new Integer[]{killer.getSiegeSide(),0,0,0,0,0,0});
+			_participantPoints.get(killer.getObjectId())[type]++;
+		}
+	}
+	
+	public int[] calcReward(L2PcInstance player)
+	{
+		if (_participantPoints.containsKey(player.getObjectId()))
+		{
+			int[] reward = new int[2];
+			Integer[] temp = _participantPoints.get(player.getObjectId());
+			reward[0] = temp[0];
+			reward[1] = 0;
+			// badges for being online. if char was not online at least 10 mins
+			// than he cant get rewards(also this will handle that player already get his/her rewards)
+			if (temp[6] < 10)
+				return reward;
+			reward[1] += (temp[6] > 70 ? 7 : (int)(temp[6] * 0.1));
+			// badges for player Quests
+			reward[1] += temp[2] * 7;
+			// badges for player Kills
+			if (temp[1] < 50)
+				reward[1] += temp[1] * 0.1;
+			else if (temp[1] < 120)
+				reward[1] += (5 + (temp[1] - 50) / 14);
+			else
+				reward[1] += 10;
+			// badges for territory npcs
+			reward[1] += temp[3];
+			// badges for territory catapults
+			reward[1] += temp[4] * 2;
+			// badges for territory Wards
+			reward[1] += (temp[5] > 0 ? 5 : 0);
+			// badges for territory quest done
+			reward[1] += Math.min(_territoryList.get(temp[0] - 80).getQuestDone()[0], 10);
+			reward[1] += _territoryList.get(temp[0] - 80).getQuestDone()[1];
+			reward[1] += _territoryList.get(temp[0] - 80).getOwnedWardIds().size();
+			return reward;
+		}
+		return new int[]{0,0};
+	}
+	
+	public void debugReward(L2PcInstance player)
+	{
+		player.sendMessage("Registred TerrId: " + player.getSiegeSide());
+		if (_participantPoints.containsKey(player.getObjectId()))
+		{
+			Integer[] temp = _participantPoints.get(player.getObjectId());
+			player.sendMessage("TerrId: " + temp[0]);
+			player.sendMessage("PcKill: " + temp[1]);
+			player.sendMessage("PcQuests: " + temp[2]);
+			player.sendMessage("npcKill: " + temp[3]);
+			player.sendMessage("CatatKill: " + temp[4]);
+			player.sendMessage("WardKill: " + temp[5]);
+			player.sendMessage("onlineTime: " + temp[6]);
+		}
+		else
+			player.sendMessage("No points for you!");
+		if (_territoryList.containsKey(player.getSiegeSide() - 80))
+		{
+			player.sendMessage("Your Territory's jobs:");
+			player.sendMessage("npcKill: " + _territoryList.get(player.getSiegeSide() - 80).getQuestDone()[0]);
+			player.sendMessage("WardCaptured: " + _territoryList.get(player.getSiegeSide() - 80).getQuestDone()[1]);
+		}
+	}
+	
+	public void resetReward(L2PcInstance player)
+	{
+		if (_participantPoints.containsKey(player.getObjectId()))
+		{
+			_participantPoints.get(player.getObjectId())[6] = 0;
+		}
+	}
+	
+	// =========================================================
+	// Method - Private
+	private L2Npc spawnNPC(int npcId, Location loc)
+	{
+		L2NpcTemplate template = NpcTable.getInstance().getTemplate(npcId);
+		if (template != null)
+		{
+			L2Spawn spawnDat;
+			try
+			{
+				spawnDat = new L2Spawn(template);
+				spawnDat.setAmount(1);
+				spawnDat.setLocx(loc.getX());
+				spawnDat.setLocy(loc.getY());
+				spawnDat.setLocz(loc.getZ());
+				spawnDat.setHeading(loc.getHeading());
+				spawnDat.stopRespawn();
+				return spawnDat.spawnOne(false);
+			}
+			catch (Exception e)
+			{
+				_log.warning("Territory War Manager: " + e.getMessage());
+				e.printStackTrace();
+				return null;
+			}
+		}
+		else
+		{
+			_log.warning("Territory War Manager: Data missing in NPC table for ID: " + npcId + ".");
+			return null;
+		}
+	}
+	
+	private void changeRegistration(int castleId, int objId, boolean delete)
+	{
+		Connection con = null;
+		PreparedStatement statement = null;
+		try
+		{
+			con = L2DatabaseFactory.getInstance().getConnection();
+			if (delete)
+				statement = con.prepareStatement("DELETE FROM territory_registrations WHERE castleId=? and registeredId=?");
+			else
+				statement = con.prepareStatement("INSERT INTO territory_registrations (castleId, registeredId) values (?,?)");
+			statement.setInt(1, castleId);
+			statement.setInt(2, objId);
+			statement.execute();
+		}
+		catch (Exception e)
+		{
+			_log.warning("Exception: Territory War registration: " + e.getMessage());
+			e.printStackTrace();
+		}
+		finally
+		{
+			try
+			{
+				statement.close();
+			}
+			catch (Exception e)
+			{
+			}
+			try
+			{
+				con.close();
+			}
+			catch (Exception e)
+			{
+			}
+		}
+	}
+	
+	private void updateTerritoryData(Territory ter)
+	{
+		Connection con = null;
+		PreparedStatement statement = null;
+		try
+		{
+			con = L2DatabaseFactory.getInstance().getConnection();
+			statement = con.prepareStatement("UPDATE territories SET ownedWardIds=? WHERE territoryId=?");
+			String wardList = "";
+			for (int i : ter.getOwnedWardIds())
+				wardList += (i + ";");
+			statement.setString(1, wardList);
+			statement.setInt(2, ter.getTerritoryId());
+			statement.execute();
+		}
+		catch (Exception e)
+		{
+			_log.warning("Exception: Territory Data update: " + e.getMessage());
+			e.printStackTrace();
+		}
+		finally
+		{
+			try
+			{
+				statement.close();
+			}
+			catch (Exception e)
+			{
+			}
+			try
+			{
+				con.close();
+			}
+			catch (Exception e)
+			{
+			}
+		}
+	}
+
+	private final void load()
+	{
+		InputStream is = null;
+		try
+		{
+			is = new FileInputStream(new File(Config.TW_CONFIGURATION_FILE));
+			L2Properties territoryWarSettings = new L2Properties();
+			territoryWarSettings.load(is);
+			
+			// Siege setting
+			DEFENDERMAXCLANS = Integer.decode(territoryWarSettings.getProperty("DefenderMaxClans", "500"));
+			DEFENDERMAXPLAYERS = Integer.decode(territoryWarSettings.getProperty("DefenderMaxPlayers", "500"));
+			CLANMINLEVEL = Integer.decode(territoryWarSettings.getProperty("ClanMinLevel", "0"));
+			PLAYERMINLEVEL = Integer.decode(territoryWarSettings.getProperty("PlayerMinLevel", "40"));
+			WARLENGTH = Long.decode(territoryWarSettings.getProperty("WarLength", "120")) * 60000;
+			PLAYER_WITH_WARD_CAN_BE_KILLED_IN_PEACEZONE = Boolean.parseBoolean(territoryWarSettings.getProperty("PlayerWithWardCanBeKilledInPeaceZone", "False"));
+			MINTWBADGEFORNOBLESS = Integer.decode(territoryWarSettings.getProperty("MinTerritoryBadgeForNobless", "100"));
+			MINTWBADGEFORSTRIDERS = Integer.decode(territoryWarSettings.getProperty("MinTerritoryBadgeForStriders", "50"));
+			MINTWBADGEFORBIGSTRIDER = Integer.decode(territoryWarSettings.getProperty("MinTerritoryBadgeForBigStrider", "80"));
+			
+			Connection con = null;
+			try
+			{
+				con = L2DatabaseFactory.getInstance().getConnection();
+				PreparedStatement statement = con.prepareStatement("SELECT * FROM territory_spawnlist");
+				ResultSet rs = statement.executeQuery();
+				
+				while (rs.next())
+				{
+					int castleId = rs.getInt("castleId");
+					int npcId = rs.getInt("npcId");
+					Location loc = new Location(rs.getInt("x"),rs.getInt("y"),rs.getInt("z"),rs.getInt("heading"));
+					int spawnType = rs.getInt("spawnType");
+					if (!_territoryList.containsKey(castleId))
+						_territoryList.put(castleId, new Territory(castleId));
+					switch(spawnType)
+					{
+						case 0: // town npcs
+						case 1: // fortress npcs
+						case 2: // castle npcs
+							_territoryList.get(castleId).getSpawnList().add(new TerritoryNPCSpawn(castleId, loc, npcId, spawnType, null));
+							break;
+						case 3: // ward spawns
+							_territoryList.get(castleId).addWardSpawnPlace(loc);
+							break;
+						default:
+							_log.warning("Territory War Manager: Unknown npc type for " + rs.getInt("id"));
+					}
+				}
+				
+				rs.close();
+				statement.close();
+			}
+			catch (Exception e)
+			{
+				_log.warning("Territory War Manager: SpawnList error: " + e.getMessage());
+				e.printStackTrace();
+			}
+			finally
+			{
+				try
+				{
+					con.close();
+				}
+				catch (Exception e)
+				{
+				}
+			}
+			try
+			{
+				con = L2DatabaseFactory.getInstance().getConnection();
+				PreparedStatement statement = con.prepareStatement("SELECT * FROM territories");
+				ResultSet rs = statement.executeQuery();
+				
+				while (rs.next())
+				{
+					int castleId = rs.getInt("castleId");
+					int fortId = rs.getInt("fortId");
+					String ownedWardIds = rs.getString("OwnedWardIds");
+					
+					Territory t = _territoryList.get(castleId);
+					if (t != null)
+					{
+						t._fortId = fortId;
+						if (CastleManager.getInstance().getCastleById(castleId).getOwnerId() > 0)
+						{
+							t.setOwnerClan(ClanTable.getInstance().getClan(CastleManager.getInstance().getCastleById(castleId).getOwnerId()));
+							t.changeNPCsSpawn(0, true);
+						}
+						
+						if (!ownedWardIds.isEmpty())
+						{
+							for(String wardId:ownedWardIds.split(";"))
+								if (Integer.parseInt(wardId) > 0)
+									addTerritoryWard(Integer.parseInt(wardId), castleId, 0);
+						}
+					}
+				}
+				rs.close();
+				statement.close();
+			}
+			catch (Exception e)
+			{
+				_log.warning("Territory War Manager: territory list error(): " + e.getMessage());
+				e.printStackTrace();
+			}
+			finally
+			{
+				try
+				{
+					con.close();
+				}
+				catch (Exception e)
+				{
+				}
+			}
+			try
+			{
+				con = L2DatabaseFactory.getInstance().getConnection();
+				PreparedStatement statement = con.prepareStatement("SELECT * FROM territory_registrations");
+				ResultSet rs = statement.executeQuery();
+				
+				while (rs.next())
+				{
+					int castleId = rs.getInt("castleId");
+					int registeredId = rs.getInt("registeredId");
+					if (ClanTable.getInstance().getClan(registeredId) != null)
+					{
+						if (_registeredClans.get(castleId) == null)
+							_registeredClans.put(castleId, new FastList<L2Clan>());
+						_registeredClans.get(castleId).add(ClanTable.getInstance().getClan(registeredId));
+					}
+					else
+					{
+						if (_registeredMercenaries.get(castleId) == null)
+							_registeredMercenaries.put(castleId, new FastList<Integer>());
+						_registeredMercenaries.get(castleId).add(registeredId);
+					}
+				}
+				rs.close();
+				statement.close();
+			}
+			catch (Exception e)
+			{
+				_log.warning("Territory War Manager: registration list error: " + e.getMessage());
+				e.printStackTrace();
+			}
+			finally
+			{
+				try
+				{
+					con.close();
+				}
+				catch (Exception e)
+				{
+				}
+			}
+		}
+		catch (Exception e)
+		{
+			//_initialized = false;
+			_log.warning("Error while loading Territory War Manager!");
+			e.printStackTrace();
+		}
+		finally
+		{
+			try
+			{
+				is.close();
+			}
+			catch (Exception e)
+			{
+			}
+		}
+	}
+	
+	private void startTerritoryWar()
+	{
+		if (_territoryList == null || _territoryList.size() < 2)
+		{
+			// change next TW date
+			return;
+		}
+		_isTWInProgress = true;
+		if (!updatePlayerTWStateFlags(false))
+			return;
+
+		// teleportPlayer(Siege.TeleportWhoType.Attacker, MapRegionTable.TeleportWhereType.Town); // Teleport to the closest town
+		for(Territory t : _territoryList.values())
+		{
+			Castle castle = CastleManager.getInstance().getCastleById(t.getCastleId());
+			Fort fort = FortManager.getInstance().getFortById(t.getFortId());
+			// spawnControlTower(t.getCastleId()); // Spawn control tower
+			if (castle != null)
+			{
+				t.changeNPCsSpawn(2, true);
+				castle.spawnDoor(); // Spawn door
+				castle.getZone().setIsActive(true);
+				castle.getZone().updateZoneStatusForCharactersInside();
+			}
+			else
+				_log.warning("TerritoryWarManager: Castle missing! CastleId: " + t.getCastleId());
+			if (fort != null)
+			{
+				t.changeNPCsSpawn(1, true);
+				fort.resetDoors(); // Spawn door
+				fort.getZone().setIsActive(true);
+				fort.getZone().updateZoneStatusForCharactersInside();
+			}
+			else
+				_log.warning("TerritoryWarManager: Fort missing! FortId: " + t.getFortId());
+			for(TerritoryNPCSpawn ward : t.getOwnedWard())
+				if (ward.getNpc() != null && t.getOwnerClan() != null)
+				{
+					ward.getNpc().setIsInvul(false);
+					ward.getNpc().broadcastStatusUpdate();
+					_territoryWards.add(new TerritoryWard(ward.getNpcId(), ward.getLocation().getX(), ward.getLocation().getY(), ward.getLocation().getZ(), 0, ward.getNpcId() + 13479, t.getCastleId(), ward.getNpc()));
+				}
+			t.getQuestDone()[0] = 0; // killed npc
+			t.getQuestDone()[1] = 0; // captured wards
+		}
+		_participantPoints.clear();
+
+		SystemMessage sm = new SystemMessage(SystemMessageId.TERRITORY_WAR_HAS_BEGUN);
+		Announcements.getInstance().announceToAll(sm);
+	}
+	
+	private void endTerritoryWar()
+	{
+		_isTWInProgress = false;
+		if (_territoryList == null || _territoryList.size() < 2)
+		{
+			// change next TW date
+			return;
+		}
+		if (!updatePlayerTWStateFlags(true))
+			return;
+
+		// teleportPlayer(Siege.TeleportWhoType.Attacker, MapRegionTable.TeleportWhereType.Town); // Teleport to the closest town
+		for(Territory t : _territoryList.values())
+		{
+			Castle castle = CastleManager.getInstance().getCastleById(t.getCastleId());
+			Fort fort = FortManager.getInstance().getFortById(t.getFortId());
+
+			if (castle != null)
+			{
+				castle.spawnDoor();
+				t.changeNPCsSpawn(2, false);
+				castle.getZone().setIsActive(false);
+				castle.getZone().updateZoneStatusForCharactersInside();
+			}
+			else
+				_log.warning("TerritoryWarManager: Castle missing! CastleId: " + t.getCastleId());
+
+			if (fort != null)
+			{
+				t.changeNPCsSpawn(1, false);
+				fort.getZone().setIsActive(false);
+				fort.getZone().updateZoneStatusForCharactersInside();
+			}
+			else
+				_log.warning("TerritoryWarManager: Fort missing! FortId: " + t.getFortId());
+			
+			if (t.getHQ() != null)
+				t.getHQ().deleteMe();
+			
+			for(TerritoryNPCSpawn ward : t.getOwnedWard())
+				if (ward.getNpc() != null)
+				{
+					if (ward.getNpc().isDecayed())
+						ward.setNPC(ward.getNpc().getSpawn().doSpawn());
+					ward.getNpc().setIsInvul(true);
+					ward.getNpc().broadcastStatusUpdate();
+				}
+		}
+		if (_territoryWards != null)
+			for(TerritoryWard twWard : _territoryWards)
+				twWard.unSpawnMe();
+		_territoryWards.clear();
+		for(L2SiegeFlagInstance flag : _clanFlags.values())
+			flag.deleteMe();
+		_clanFlags.clear();
+		
+		for(Integer castleId:_registeredClans.keySet())
+			for(L2Clan clan:_registeredClans.get(castleId))
+				changeRegistration(castleId, clan.getClanId(), true);
+		for(Integer castleId:_registeredMercenaries.keySet())
+			for(Integer pl_objId:_registeredMercenaries.get(castleId))
+				changeRegistration(castleId, pl_objId, true);
+		// change next TW date
+		SystemMessage sm = new SystemMessage(SystemMessageId.TERRITORY_WAR_HAS_ENDED);
+		Announcements.getInstance().announceToAll(sm);
+	}
+
+	private boolean updatePlayerTWStateFlags(boolean clear)
+	{
+		Quest twQuest = QuestManager.getInstance().getQuest(qn);
+		if (twQuest == null)
+		{
+			_log.warning("TerritoryWarManager: missing main Quest!");
+			return false;
+		}
+		for(int castleId : _registeredClans.keySet())
+			for(L2Clan clan : _registeredClans.get(castleId))
+				for(L2PcInstance player : clan.getOnlineMembers(0))
+				{
+					if (player == null)
+						continue;
+					if (clear)
+					{
+						player.setSiegeState((byte) 0);
+						if (!_isTWChannelOpen)
+							player.setSiegeSide(0);
+					}
+					else
+					{
+						if (player.getLevel() < PLAYERMINLEVEL || player.getClassId().level() < 2)
+							continue;
+						if (_isTWInProgress)
+						{
+							player.setSiegeState((byte) 1);
+						}
+						player.setSiegeSide(80 + castleId);
+					}
+					player.sendPacket(new UserInfo(player));
+					player.sendPacket(new ExBrExtraUserInfo(player));
+					for (L2PcInstance knownPlayer : player.getKnownList().getKnownPlayers().values())
+					{
+						try
+						{
+							knownPlayer.sendPacket(new RelationChanged(player, player.getRelation(knownPlayer), player.isAutoAttackable(knownPlayer)));
+							if (player.getPet() != null)
+								knownPlayer.sendPacket(new RelationChanged(player.getPet(), player.getRelation(knownPlayer), player.isAutoAttackable(knownPlayer)));
+						}
+						catch (NullPointerException e)
+						{
+						}
+					}
+				}
+		for(int castleId : _registeredMercenaries.keySet())
+			for(int objId : _registeredMercenaries.get(castleId))
+			{
+				L2PcInstance player = L2World.getInstance().getPlayer(objId);
+				if (player == null)
+					continue;
+				if (clear)
+				{
+					player.setSiegeState((byte) 0);
+					if (!_isTWChannelOpen)
+						player.setSiegeSide(0);
+				}
+				else
+				{
+					if (_isTWInProgress)
+					{
+						player.setSiegeState((byte) 1);
+					}
+					player.setSiegeSide(80 + castleId);
+				}
+				player.sendPacket(new UserInfo(player));
+				player.sendPacket(new ExBrExtraUserInfo(player));
+				for (L2PcInstance knownPlayer : player.getKnownList().getKnownPlayers().values())
+				{
+					try
+					{
+						knownPlayer.sendPacket(new RelationChanged(player, player.getRelation(knownPlayer), player.isAutoAttackable(knownPlayer)));
+						if (player.getPet() != null)
+							knownPlayer.sendPacket(new RelationChanged(player.getPet(), player.getRelation(knownPlayer), player.isAutoAttackable(knownPlayer)));
+					}
+					catch (NullPointerException e)
+					{
+					}
+				}
+			}
+		for(Territory terr : _territoryList.values())
+			if (terr.getOwnerClan() != null)
+				for(L2PcInstance player : terr.getOwnerClan().getOnlineMembers(0))
+				{
+					if (player == null)
+						continue;
+					if (clear)
+					{
+						player.setSiegeState((byte) 0);
+						if (!_isTWChannelOpen)
+							player.setSiegeSide(0);
+					}
+					else
+					{
+						if (player.getLevel() < PLAYERMINLEVEL || player.getClassId().level() < 2)
+							continue;
+						if (_isTWInProgress)
+						{
+							player.setSiegeState((byte) 1);
+						}
+						player.setSiegeSide(80 + terr.getCastleId());
+					}
+					player.sendPacket(new UserInfo(player));
+					player.sendPacket(new ExBrExtraUserInfo(player));
+					for (L2PcInstance knownPlayer : player.getKnownList().getKnownPlayers().values())
+					{
+						try
+						{
+							knownPlayer.sendPacket(new CharInfo(player));
+							knownPlayer.sendPacket(new RelationChanged(player, player.getRelation(knownPlayer), player.isAutoAttackable(knownPlayer)));
+							if (player.getPet() != null)
+								knownPlayer.sendPacket(new RelationChanged(player.getPet(), player.getRelation(knownPlayer), player.isAutoAttackable(knownPlayer)));
+						}
+						catch (NullPointerException e)
+						{
+						}
+					}
+				}
+		twQuest.setOnEnterWorld(_isTWInProgress);
+		return true;
+	}
+	
+	private class RewardOnlineParticipants implements Runnable
+	{
+		public RewardOnlineParticipants()
+		{
+		}
+
+		public void run()
+		{
+			if (isTWInProgress())
+			{
+				for(L2PcInstance player : L2World.getInstance().getAllPlayers().values())
+					if (player.getSiegeSide() > 0)
+						giveTWPoint(player, 1000, 6);
+			}
+			else
+				_scheduledRewardOnlineTask.cancel(false);
+		}
+	}
+
+	private class ScheduleStartTWTask implements Runnable
+	{
+		public ScheduleStartTWTask()
+		{
+		}
+
+		public void run()
+		{
+			_scheduledStartTWTask.cancel(false);
+			try
+			{
+				long timeRemaining = _startTWDate.getTimeInMillis() - Calendar.getInstance().getTimeInMillis();
+				if (timeRemaining > 7200000)
+				{
+					_isRegistrationOver = false;
+					_scheduledStartTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartTWTask(), timeRemaining - 7200000); // Prepare task for 2h before TW start to end registration
+				}
+				else if ((timeRemaining <= 7200000) && (timeRemaining > 1200000))
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.THE_TERRITORY_WAR_REGISTERING_PERIOD_ENDED);
+					Announcements.getInstance().announceToAll(sm);
+					_isRegistrationOver = true;
+					_scheduledStartTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartTWTask(), timeRemaining - 1200000); // Prepare task for 20 mins left before TW start.
+				}
+				else if ((timeRemaining <= 1200000) && (timeRemaining > 600000))
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.TERRITORY_WAR_BEGINS_IN_20_MINUTES);
+					Announcements.getInstance().announceToAll(sm);
+					_isTWChannelOpen = true;
+					_isRegistrationOver = true;
+					updatePlayerTWStateFlags(false);
+					_scheduledStartTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartTWTask(), timeRemaining - 600000); // Prepare task for 10 mins left before TW start.
+				}
+				else if ((timeRemaining <= 600000) && (timeRemaining > 300000))
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.TERRITORY_WAR_BEGINS_IN_10_MINUTES);
+					Announcements.getInstance().announceToAll(sm);
+					_isTWChannelOpen = true;
+					_isRegistrationOver = true;
+					updatePlayerTWStateFlags(false);
+					_scheduledStartTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartTWTask(), timeRemaining - 300000); // Prepare task for 5 mins left before TW start.
+				}
+				else if ((timeRemaining <= 300000) && (timeRemaining > 60000))
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.TERRITORY_WAR_BEGINS_IN_5_MINUTES);
+					Announcements.getInstance().announceToAll(sm);
+					_isTWChannelOpen = true;
+					_isRegistrationOver = true;
+					updatePlayerTWStateFlags(false);
+					_scheduledStartTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartTWTask(), timeRemaining - 60000); // Prepare task for 1 min left before TW start.
+				}
+				else if ((timeRemaining <= 60000) && (timeRemaining > 0))
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.TERRITORY_WAR_BEGINS_IN_1_MINUTE);
+					Announcements.getInstance().announceToAll(sm);
+					_isTWChannelOpen = true;
+					_isRegistrationOver = true;
+					updatePlayerTWStateFlags(false);
+					_scheduledStartTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartTWTask(), timeRemaining); // Prepare task for TW start.
+				}
+				else
+				{
+					_isTWChannelOpen = true;
+					_isRegistrationOver = true;
+					startTerritoryWar();
+					_scheduledEndTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleEndTWTask(), 1000); // Prepare task for TW end.
+					_scheduledRewardOnlineTask = ThreadPoolManager.getInstance().scheduleGeneralAtFixedRate(new RewardOnlineParticipants(), 60000, 60000);
+				}
+			}
+			catch (Exception e)
+			{
+				_log.log(Level.SEVERE, "", e);
+			}
+		}
+	}
+	
+	private class ScheduleEndTWTask implements Runnable
+	{
+		public ScheduleEndTWTask()
+		{
+		}
+
+		public void run()
+		{
+			try
+			{
+				_scheduledEndTWTask.cancel(false);
+				long timeRemaining = _startTWDate.getTimeInMillis() + WARLENGTH - Calendar.getInstance().getTimeInMillis();
+				if (timeRemaining > 3600000)
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.THE_TERRITORY_WAR_WILL_END_IN_S1_HOURS);
+					sm.addNumber(2);
+					announceToParticipants(sm, 0, 0);
+					_scheduledEndTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleEndTWTask(), timeRemaining - 3600000); // Prepare task for 1 hr left.
+				}
+				else if ((timeRemaining <= 3600000) && (timeRemaining > 600000))
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.THE_TERRITORY_WAR_WILL_END_IN_S1_MINUTES);
+					sm.addNumber(Math.round(timeRemaining / 60000));
+					announceToParticipants(sm, 0, 0);
+					_scheduledEndTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleEndTWTask(), timeRemaining - 600000); // Prepare task for 10 minute left.
+				}
+				else if ((timeRemaining <= 600000) && (timeRemaining > 300000))
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.THE_TERRITORY_WAR_WILL_END_IN_S1_MINUTES);
+					sm.addNumber(Math.round(timeRemaining / 60000));
+					announceToParticipants(sm, 0, 0);
+					_scheduledEndTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleEndTWTask(), timeRemaining - 300000); // Prepare task for 5 minute left.
+				}
+				else if ((timeRemaining <= 300000) && (timeRemaining > 10000))
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.THE_TERRITORY_WAR_WILL_END_IN_S1_MINUTES);
+					sm.addNumber(Math.round(timeRemaining / 60000));
+					announceToParticipants(sm, 0, 0);
+					_scheduledEndTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleEndTWTask(), timeRemaining - 10000); // Prepare task for 10 seconds count down
+				}
+				else if ((timeRemaining <= 10000) && (timeRemaining > 0))
+				{
+					SystemMessage sm = new SystemMessage(SystemMessageId.S1_SECONDS_TO_THE_END_OF_TERRITORY_WAR);
+					sm.addNumber(Math.round(timeRemaining / 1000));
+					announceToParticipants(sm, 0, 0);
+					_scheduledEndTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleEndTWTask(), timeRemaining); // Prepare task for second count down
+				}
+				else
+				{
+					endTerritoryWar();
+					// _scheduledStartTWTask = ThreadPoolManager.getInstance().scheduleGeneral(new ScheduleStartTWTask(), 1000);
+					ThreadPoolManager.getInstance().scheduleGeneral(new closeTerritoryChannelTask(), 600000);
+				}
+			}
+			catch (Exception e)
+			{
+				_log.log(Level.SEVERE, "", e);
+			}
+		}
+	}
+	
+	private class closeTerritoryChannelTask implements Runnable
+	{
+		public closeTerritoryChannelTask()
+		{
+		}
+
+		public void run()
+		{
+			_isTWChannelOpen = false;
+			_disguisedPlayers.clear();
+			updatePlayerTWStateFlags(true);
+		}
+	}
+	
+	public void announceToParticipants(L2GameServerPacket sm, int exp, int sp)
+	{
+		// broadcast to clan members
+		for(Territory ter : _territoryList.values())
+			if (ter.getOwnerClan() != null)
+				for (L2PcInstance member : ter.getOwnerClan().getOnlineMembers(0))
+				{
+					member.sendPacket(sm);
+					if (exp > 0 || sp > 0)
+						member.addExpAndSp(exp, sp);
+				}
+		for(FastList<L2Clan> list:_registeredClans.values())
+			for(L2Clan c:list)
+				for (L2PcInstance member : c.getOnlineMembers(0))
+				{
+					member.sendPacket(sm);
+					if (exp > 0 || sp > 0)
+						member.addExpAndSp(exp, sp);
+				}
+		// broadcast to mercenaries
+		for(FastList<Integer> list:_registeredMercenaries.values())
+			for(int objId:list)
+			{
+				L2PcInstance player = L2World.getInstance().getPlayer(objId);
+				if (player != null && (player.getClan() == null || !checkIsRegistered(-1, player.getClan())))
+				{
+					player.sendPacket(sm);
+					if (exp > 0 || sp > 0)
+						player.addExpAndSp(exp, sp);
+				}
+			}
+	}
+	// =========================================================
+	// Property - Public
+	public class TerritoryNPCSpawn
+	{
+		private Location _location;
+		private int _npcId;
+		private int _castleId;
+		private int _type;
+		private L2Npc _npc;
+		
+		public TerritoryNPCSpawn(int castle_id, Location loc, int npc_id, int type, L2Npc npc)
+		{
+			_castleId = castle_id;
+			_location = loc;
+			_npcId = npc_id;
+			_type = type;
+			_npc = npc;
+		}
+		
+		public int getCastleId()
+		{
+			return _castleId;
+		}
+		
+		public int getNpcId()
+		{
+			return _npcId;
+		}
+		
+		public int getType()
+		{
+			return _type;
+		}
+		
+		public void setNPC(L2Npc npc)
+		{
+			_npc = npc;
+		}
+		
+		public L2Npc getNpc()
+		{
+			return _npc;
+		}
+		
+		public Location getLocation()
+		{
+			return _location;
+		}
+	}
+	
+	public class Territory
+	{
+		private final int _territoryId;
+		private final int _castleId; // territory Castle
+		private int _fortId; // territory Fortress
+		private L2Clan _ownerClan;
+		private FastList<TerritoryNPCSpawn> _spawnList;
+		private TerritoryNPCSpawn[] _territoryWardSpawnPlaces;
+		private boolean _isInProgress = false;
+		private L2SiegeFlagInstance _territoryHQ = null;
+		private int[] _questDone;
+		
+		public Territory(int castleId)
+		{
+			_castleId = castleId;
+			_territoryId = castleId + 80;
+			_spawnList = new FastList<TerritoryNPCSpawn>();
+			_territoryWardSpawnPlaces = new TerritoryNPCSpawn[9];
+			_questDone = new int[2];
+		}
+		
+		private void addWardSpawnPlace(Location loc)
+		{
+			for(int i = 0; i < _territoryWardSpawnPlaces.length; i++)
+				if (_territoryWardSpawnPlaces[i] == null)
+				{
+					_territoryWardSpawnPlaces[i] = new TerritoryNPCSpawn(_castleId, loc, 0, 4, null);
+					return;
+				}
+		}
+		
+		private TerritoryNPCSpawn getFreeWardSpawnPlace()
+		{
+			for(int i = 0; i < _territoryWardSpawnPlaces.length; i++)
+				if (_territoryWardSpawnPlaces[i] != null && _territoryWardSpawnPlaces[i].getNpc() == null)
+					return _territoryWardSpawnPlaces[i];
+			_log.log(Level.WARNING, "TerritoryWarManager: no free Ward spawn found for territory: " + _territoryId);
+			for(int i = 0; i < _territoryWardSpawnPlaces.length; i++)
+				if (_territoryWardSpawnPlaces[i] == null)
+					_log.log(Level.WARNING, "TerritoryWarManager: territory ward spawn place " + i + " is null!");
+				else if (_territoryWardSpawnPlaces[i].getNpc() != null)
+					_log.log(Level.WARNING, "TerritoryWarManager: territory ward spawn place " + i + " has npc name: " + _territoryWardSpawnPlaces[i].getNpc().getName());
+				else
+					_log.log(Level.WARNING, "TerritoryWarManager: territory ward spawn place " + i + " is empty!");
+			return null;
+		}
+		
+		public FastList<TerritoryNPCSpawn> getSpawnList()
+		{
+			return _spawnList;
+		}
+		
+		private void changeNPCsSpawn(int type, boolean isSpawn)
+		{
+			if (type < 0 || type > 3)
+			{
+				_log.log(Level.WARNING, "TerritoryWarManager: wrong type(" + type + ") for NPCs spawn change!");
+				return;
+			}
+			for(TerritoryNPCSpawn twSpawn : _spawnList)
+			{
+				if (twSpawn.getType() != type)
+					continue;
+				if (isSpawn)
+					twSpawn.setNPC(spawnNPC(twSpawn.getNpcId(), twSpawn.getLocation()));
+				else
+				{
+					L2Npc npc = twSpawn.getNpc();
+					if (npc != null && !npc.isDead())
+						npc.deleteMe();
+					twSpawn.setNPC(null);
+				}
+			}
+		}
+		
+		private void removeWard(int wardId)
+		{
+			for(TerritoryNPCSpawn wardSpawn : _territoryWardSpawnPlaces)
+				if (wardSpawn.getNpcId() == wardId)
+				{
+					wardSpawn.getNpc().deleteMe();
+					wardSpawn.setNPC(null);
+					wardSpawn._npcId = 0;
+					return;
+				}
+			_log.log(Level.WARNING, "TerritoryWarManager: cant delete wardId: " + wardId + " for territory: " + _territoryId);
+		}
+		
+		public int getTerritoryId()
+		{
+			return _territoryId;
+		}
+		
+		public int getCastleId()
+		{
+			return _castleId;
+		}
+		
+		public int getFortId()
+		{
+			return _fortId;
+		}
+		
+		public L2Clan getOwnerClan()
+		{
+			return _ownerClan;
+		}
+		
+		public void setOwnerClan(L2Clan newOwner)
+		{
+			_ownerClan = newOwner;
+		}
+		
+		public void setHQ(L2SiegeFlagInstance hq)
+		{
+			_territoryHQ = hq;
+		}
+		
+		public L2SiegeFlagInstance getHQ()
+		{
+			return _territoryHQ;
+		}
+		
+		public TerritoryNPCSpawn[] getOwnedWard()
+		{
+			return _territoryWardSpawnPlaces;
+		}
+		
+		public int[] getQuestDone()
+		{
+			return _questDone;
+		}
+		
+		public FastList<Integer> getOwnedWardIds()
+		{
+			FastList<Integer> ret = new FastList<Integer>();
+			for(TerritoryNPCSpawn wardSpawn : _territoryWardSpawnPlaces)
+				if (wardSpawn.getNpcId() > 0)
+					ret.add(wardSpawn.getNpcId());
+			return ret;
+		}
+		
+		public boolean getIsInProgress()
+		{
+			return _isInProgress;
+		}
+		
+		public void setIsInProgress(boolean val)
+		{
+			_isInProgress = val;
+		}
+	}
+	@SuppressWarnings("synthetic-access")
+	private static class SingletonHolder
+	{
+		protected static final TerritoryWarManager _instance = new TerritoryWarManager();
+	}
+}

L2_GameServer/java/com/l2jserver/gameserver/model/L2Clan.java

@@ -273,7 +273,7 @@ public class L2Clan
         	// Transferring siege skills TimeStamps from old leader to new leader to prevent unlimited headquarters
         	if (!exLeader.getReuseTimeStamp().isEmpty())
         	{
-        		for (L2Skill sk : SkillTable.getInstance().getSiegeSkills(newLeader.isNoble()))
+        		for (L2Skill sk : SkillTable.getInstance().getSiegeSkills(newLeader.isNoble(), getHasCastle() > 0))
         		{
         			if (exLeader.getReuseTimeStamp().containsKey(sk.getReuseHashCode()))
         			{

L2_GameServer/java/com/l2jserver/gameserver/model/L2Skill.java

@@ -2194,6 +2194,11 @@ public abstract class L2Skill implements IChanceSkillTrigger
     			if (targetPlayer.inObserverMode())
     				return false;
 
+    			if (skill.isOffensive() && player.getSiegeState() > 0 && player.isInsideZone(L2Character.ZONE_SIEGE)
+    					&& player.getSiegeState() == targetPlayer.getSiegeState()
+    					&& player.getSiegeSide() == targetPlayer.getSiegeSide())
+    				return false;
+    			
     			if (target.isInsideZone(L2Character.ZONE_PEACE))
     				return false;
 

L2_GameServer/java/com/l2jserver/gameserver/model/TerritoryWard.java

@@ -0,0 +1,180 @@
+/*
+ * This program 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.
+ * 
+ * This program 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;
+
+import com.l2jserver.Config;
+import com.l2jserver.gameserver.datatables.ItemTable;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
+import com.l2jserver.gameserver.model.actor.L2Npc;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.InventoryUpdate;
+import com.l2jserver.gameserver.network.serverpackets.ItemList;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
+public class TerritoryWard
+{
+	//private static final Logger _log = Logger.getLogger(CombatFlag.class.getName());
+
+	protected L2PcInstance _player = null;
+	public int playerId = 0;
+	private L2ItemInstance _item = null;
+	private L2Npc _npc = null;
+
+	private Location _location;
+	public L2ItemInstance itemInstance;
+	
+	private int _itemId;
+	private int _ownerCastleId;
+	
+	@SuppressWarnings("unused")
+	private int _heading;
+	private int _territoryId;
+	
+	// =========================================================
+	// Constructor
+	public TerritoryWard(int territory_id, int x, int y, int z, int heading, int item_id, int castleId, L2Npc npc)
+	{
+		_territoryId = territory_id;
+		_location = new Location(x,y,z,heading);
+		_heading = heading;
+		_itemId = item_id;
+		_ownerCastleId = castleId;
+		_npc = npc;
+	}
+
+	public int getTerritoryId()
+	{
+		return _territoryId;
+	}
+	
+	public int getOwnerCastleId()
+	{
+		return _ownerCastleId;
+	}
+	
+	public void setOwnerCastleId(int newOwner)
+	{
+		_ownerCastleId = newOwner;
+	}
+	
+	public L2Npc getNpc()
+	{
+		return _npc;
+	}
+	
+	public void setNpc(L2Npc npc)
+	{
+		_npc = npc;
+	}
+	
+	public L2PcInstance getPlayer()
+	{
+		return _player;
+	}
+	
+	public L2ItemInstance getItemInstance()
+	{
+		return itemInstance;
+	}
+	
+	public synchronized void spawnMe()
+	{
+		if ( _player != null )
+			dropIt();
+		L2ItemInstance i;
+		
+		// Init the dropped L2ItemInstance and add it in the world as a visible object at the position where mob was last
+		i = ItemTable.getInstance().createItem("Combat", _itemId, 1, null, null);
+		i.spawnMe(_location.getX(), _location.getY(), _location.getZ());
+		itemInstance = i;
+		_npc = null;
+	}
+
+	public synchronized void unSpawnMe()
+	{
+		if ( _player != null )
+			dropIt();
+		
+		if ( itemInstance != null )
+		{
+			itemInstance.decayMe();
+		}
+	}
+	
+	public boolean activate(L2PcInstance player, L2ItemInstance item)
+	{
+		if (player.isMounted())
+		{
+			player.sendPacket(new SystemMessage(SystemMessageId.CANNOT_EQUIP_ITEM_DUE_TO_BAD_CONDITION));
+			player.destroyItem("CombatFlag", item, null, true);
+			spawnMe();
+			return false;
+		}
+		else if (TerritoryWarManager.getInstance().getRegisteredTerritoryId(player) == 0)
+		{
+			player.sendMessage("Non participants can't pickup Territory Wards!");
+			player.destroyItem("CombatFlag", item, null, true);
+			spawnMe();
+			return false;
+		}
+
+		// Player holding it data
+		_player = player;
+		playerId = _player.getObjectId();
+		itemInstance = null;
+		_npc = null;
+
+		// Equip with the weapon
+		if (item == null)
+			_item = ItemTable.getInstance().createItem("Combat", _itemId, 1, null, null);
+		else
+			_item = item;
+		_player.getInventory().equipItemAndRecord(_item);
+		SystemMessage sm = new SystemMessage(SystemMessageId.S1_EQUIPPED);
+		sm.addItemName(_item);
+		_player.sendPacket(sm);
+
+		// Refresh inventory
+		if (!Config.FORCE_INVENTORY_UPDATE)
+		{
+			InventoryUpdate iu = new InventoryUpdate();
+			iu.addItem(_item);
+			_player.sendPacket(iu);
+		}
+		else _player.sendPacket(new ItemList(_player, false));
+		
+		// Refresh player stats
+		_player.broadcastUserInfo();
+		_player.setCombatFlagEquipped(true);
+		_player.sendPacket(new SystemMessage(SystemMessageId.YOU_VE_ACQUIRED_THE_WARD));
+		TerritoryWarManager.getInstance().giveTWPoint(player, _territoryId, 5);
+		return true;
+	}
+
+	public void dropIt()
+	{
+		// Reset player stats
+		_player.setCombatFlagEquipped(false);
+		int slot = _player.getInventory().getSlotFromItem(_item);
+		_player.getInventory().unEquipItemInBodySlotAndRecord(slot);
+		_player.destroyItem("CombatFlag", _item, null, true);
+		_item = null;
+		_player.broadcastUserInfo();
+		_location = new Location(_player.getX(),_player.getY(),_player.getZ(),_player.getHeading());
+		_player = null;
+		playerId = 0;
+	}
+}

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

@@ -43,6 +43,7 @@ import com.l2jserver.gameserver.handler.ISkillHandler;
 import com.l2jserver.gameserver.handler.SkillHandler;
 import com.l2jserver.gameserver.instancemanager.DimensionalRiftManager;
 import com.l2jserver.gameserver.instancemanager.InstanceManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.instancemanager.TownManager;
 import com.l2jserver.gameserver.model.ChanceSkillList;
 import com.l2jserver.gameserver.model.CharEffectList;
@@ -721,6 +722,19 @@ public abstract class L2Character extends L2Object
 	            return;
 	        }
 
+			if (target.getActingPlayer() != null && ((L2PcInstance)this).getSiegeState() > 0 && this.isInsideZone(L2Character.ZONE_SIEGE)
+					&& target.getActingPlayer().getSiegeState() == ((L2PcInstance)this).getSiegeState()
+					&& target.getActingPlayer() != this && target.getActingPlayer().getSiegeSide() == ((L2PcInstance)this).getSiegeSide())
+			{
+				// 
+				if (TerritoryWarManager.getInstance().isTWInProgress())
+					sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_ATTACK_A_MEMBER_OF_THE_SAME_TERRITORY));
+				else
+					sendPacket(new SystemMessage(SystemMessageId.FORCED_ATTACK_IS_IMPOSSIBLE_AGAINST_SIEGE_SIDE_TEMPORARY_ALLIED_MEMBERS));
+				sendPacket(ActionFailed.STATIC_PACKET);
+				return;
+			}
+			
 			// Checking if target has moved to peace zone
 			if (target.isInsidePeaceZone((L2PcInstance)this))
 			{
@@ -5467,6 +5481,13 @@ public abstract class L2Character extends L2Object
 		if (InstanceManager.getInstance().getInstance(this.getInstanceId()).isPvPInstance())
 			return false;
 
+		if (TerritoryWarManager.PLAYER_WITH_WARD_CAN_BE_KILLED_IN_PEACEZONE
+				&& TerritoryWarManager.getInstance().isTWInProgress())
+		{
+			if (target instanceof L2PcInstance && ((L2PcInstance)target).isCombatFlagEquipped())
+				return false;
+		}
+
 		if (Config.ALT_GAME_KARMA_PLAYER_CAN_BE_KILLED_IN_PEACEZONE)
 		{
 			// allows red to be attacked and red to attack flagged players

L2_GameServer/java/com/l2jserver/gameserver/model/actor/L2Summon.java

@@ -20,6 +20,7 @@ import com.l2jserver.gameserver.ai.CtrlIntention;
 import com.l2jserver.gameserver.ai.L2CharacterAI;
 import com.l2jserver.gameserver.ai.L2SummonAI;
 import com.l2jserver.gameserver.datatables.ItemTable;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2ItemInstance;
 import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.L2Party;
@@ -644,6 +645,19 @@ public abstract class L2Summon extends L2Playable
 				return;
 			}
 
+			if (target.getActingPlayer() != null && this.getOwner().getSiegeState() > 0 && this.getOwner().isInsideZone(L2Character.ZONE_SIEGE)
+					&& target.getActingPlayer().getSiegeState() == this.getOwner().getSiegeState()
+					&& target.getActingPlayer() != this.getOwner() && target.getActingPlayer().getSiegeSide() == this.getOwner().getSiegeSide())
+			{
+				// 
+				if (TerritoryWarManager.getInstance().isTWInProgress())
+					sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_ATTACK_A_MEMBER_OF_THE_SAME_TERRITORY));
+				else
+					sendPacket(new SystemMessage(SystemMessageId.FORCED_ATTACK_IS_IMPOSSIBLE_AGAINST_SIEGE_SIDE_TEMPORARY_ALLIED_MEMBERS));
+				sendPacket(ActionFailed.STATIC_PACKET);
+				return;
+			}
+
             // Check if the target is attackable
 			if (target instanceof L2DoorInstance)
         	{

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2CastleBlacksmithInstance.java

@@ -116,7 +116,7 @@ public class L2CastleBlacksmithInstance extends L2NpcInstance
 		{
 			if (player.getClan() != null)
 			{
-				if (getCastle().getSiege().getIsInProgress())
+				if (getCastle().getZone().isActive())
 					return COND_BUSY_BECAUSE_OF_SIEGE;                  // Busy because of siege
 				else if (getCastle().getOwnerId() == player.getClanId() // Clan owns castle
 						&& (player.getClanPrivileges() & L2Clan.CP_CS_MANOR_ADMIN) == L2Clan.CP_CS_MANOR_ADMIN)                       // Leader of clan

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2CastleChamberlainInstance.java

@@ -135,7 +135,7 @@ public class L2CastleChamberlainInstance extends L2MerchantInstance
 			{
 				if ((player.getClanPrivileges() & L2Clan.CP_CS_MANAGE_SIEGE) == L2Clan.CP_CS_MANAGE_SIEGE)
 				{
-					player.sendPacket(new ExShowDominionRegistry(getCastle().getCastleId()));
+					player.sendPacket(new ExShowDominionRegistry(getCastle().getCastleId(), player));
 					return;
 				}
 				else
@@ -1490,7 +1490,7 @@ public class L2CastleChamberlainInstance extends L2MerchantInstance
 		{
 			if (player.getClan() != null)
 			{
-				if (getCastle().getSiege().getIsInProgress())
+				if (getCastle().getZone().isActive())
 					return COND_BUSY_BECAUSE_OF_SIEGE; // Busy because of siege
 				else if (getCastle().getOwnerId() == player.getClanId()) // Clan owns castle
 					return COND_OWNER; // Owner

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2CastleMagicianInstance.java

@@ -151,7 +151,7 @@ public class L2CastleMagicianInstance extends L2NpcInstance
 		{
 			if (player.getClan() != null)
 			{
-				if (getCastle().getSiege().getIsInProgress())
+				if (getCastle().getZone().isActive())
 					return COND_BUSY_BECAUSE_OF_SIEGE;                   // Busy because of siege
 				else if (getCastle().getOwnerId() == player.getClanId()) // Clan owns castle
 					return COND_OWNER;

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2CastleWarehouseInstance.java

@@ -78,7 +78,7 @@ public class L2CastleWarehouseInstance extends L2WarehouseInstance
 		{
 			if (player.getClan() != null)
 			{
-				if (getCastle().getSiege().getIsInProgress())
+				if (getCastle().getZone().isActive())
 					return COND_BUSY_BECAUSE_OF_SIEGE;
 				else if (getCastle().getOwnerId() == player.getClanId())
 					return COND_OWNER;

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2CastleWyvernManagerInstance.java

@@ -40,6 +40,6 @@ public class L2CastleWyvernManagerInstance extends L2WyvernManagerInstance
 	@Override
 	public boolean isInSiege()
 	{
-		return getCastle().getSiege().getIsInProgress();
+		return getCastle().getZone().isActive();
 	}
 }

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2ClanHallManagerInstance.java

@@ -1389,7 +1389,12 @@ public class L2ClanHallManagerInstance extends L2MerchantInstance
         L2TeleportLocation list = TeleportLocationTable.getInstance().getTemplate(val);
         if (list != null)
         {
-            if(player.reduceAdena("Teleport", list.getPrice(), this, true))
+        	if (player.isCombatFlagEquipped())
+        	{
+        		player.sendMessage("You can't teleport with a Combat Flag or Territory Ward!");
+        		return;
+        	}
+        	else if(player.reduceAdena("Teleport", list.getPrice(), this, true))
             {
                 if (Config.DEBUG)
                  _log.warning("Teleporting player "+player.getName()+" for CH to new location: "+list.getLocX()+":"+list.getLocY()+":"+list.getLocZ());

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2DefenderInstance.java

@@ -21,6 +21,7 @@ import com.l2jserver.gameserver.ai.L2FortSiegeGuardAI;
 import com.l2jserver.gameserver.ai.L2SiegeGuardAI;
 import com.l2jserver.gameserver.instancemanager.CastleManager;
 import com.l2jserver.gameserver.instancemanager.FortManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2CharPosition;
 import com.l2jserver.gameserver.model.actor.L2Attackable;
 import com.l2jserver.gameserver.model.actor.L2Character;
@@ -99,7 +100,8 @@ public class L2DefenderInstance extends L2Attackable
 
 			// Check if player is an enemy of this defender npc
 			if (player != null && ((player.getSiegeState() == 2 && !player.isRegisteredOnThisSiegeField(activeSiegeId))
-					|| player.getSiegeState() == 1 || player.getSiegeState() == 0))
+					|| (player.getSiegeState() == 1 && !TerritoryWarManager.getInstance().isAllyField(player, activeSiegeId))
+					|| player.getSiegeState() == 0))
 			{
 				return true;
 			}
@@ -218,7 +220,8 @@ public class L2DefenderInstance extends L2Attackable
 						|| (_castle != null && _castle.getZone().isActive()))
 				{
 					int activeSiegeId = (_fort != null ? _fort.getFortId() : (_castle != null ? _castle.getCastleId() : 0));
-					if (player != null && player.getSiegeState() == 2 && player.isRegisteredOnThisSiegeField(activeSiegeId))
+					if (player != null && ((player.getSiegeState() == 2 && player.isRegisteredOnThisSiegeField(activeSiegeId))
+							|| (player.getSiegeState() == 1 && TerritoryWarManager.getInstance().isAllyField(player, activeSiegeId))))
 						return;
 				}
 			}

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2DoorInstance.java

@@ -25,6 +25,7 @@ import com.l2jserver.gameserver.ai.L2CharacterAI;
 import com.l2jserver.gameserver.ai.L2DoorAI;
 import com.l2jserver.gameserver.instancemanager.CastleManager;
 import com.l2jserver.gameserver.instancemanager.FortManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2CharPosition;
 import com.l2jserver.gameserver.model.L2Clan;
 import com.l2jserver.gameserver.model.L2ItemInstance;
@@ -356,9 +357,9 @@ public class L2DoorInstance extends L2Character
 	
 	public boolean isEnemy()
 	{
-		if (getCastle() != null && getCastle().getCastleId() > 0 && getCastle().getSiege().getIsInProgress())
+		if (getCastle() != null && getCastle().getCastleId() > 0 && getCastle().getZone().isActive())
 			return true;
-		if (getFort() != null && getFort().getFortId() > 0 && getFort().getSiege().getIsInProgress() && !getIsCommanderDoor())
+		if (getFort() != null && getFort().getFortId() > 0 && getFort().getZone().isActive() && !getIsCommanderDoor())
 			return true;
 		return false;
 	}
@@ -377,38 +378,29 @@ public class L2DoorInstance extends L2Character
 			return false;
 
 		// Attackable  only during siege by everyone (not owner)
-		boolean isCastle = (getCastle() != null && getCastle().getCastleId() > 0 && getCastle().getSiege().getIsInProgress());
-        boolean isFort = (getFort() != null && getFort().getFortId() > 0 && getFort().getSiege().getIsInProgress() && !getIsCommanderDoor());
+		boolean isCastle = (getCastle() != null && getCastle().getCastleId() > 0 && getCastle().getZone().isActive());
+		boolean isFort = (getFort() != null && getFort().getFortId() > 0 && getFort().getZone().isActive() && !getIsCommanderDoor());
+		int activeSiegeId = (getFort() != null ? getFort().getFortId() : (getCastle() != null ? getCastle().getCastleId() : 0));
+		L2PcInstance actingPlayer = attacker.getActingPlayer();
 		
-		if (isFort)
+		if (TerritoryWarManager.getInstance().isTWInProgress())
 		{
-			if (attacker instanceof L2SummonInstance)
-			{
-				L2Clan clan = ((L2SummonInstance)attacker).getOwner().getClan();
-				if (clan != null && clan == getFort().getOwnerClan())
-					return false;
-			}
-			else if (attacker instanceof L2PcInstance)
-			{
-				L2Clan clan = ((L2PcInstance)attacker).getClan();
-				if (clan != null && clan == getFort().getOwnerClan())
-					return false;
-			}
+			if (TerritoryWarManager.getInstance().isAllyField(actingPlayer, activeSiegeId))
+				return false;
+			else
+				return true;
+		}
+		else if (isFort)
+		{
+			L2Clan clan = actingPlayer.getClan();
+			if (clan != null && clan == getFort().getOwnerClan())
+				return false;
 		}
 		else if (isCastle)
 		{
-			if (attacker instanceof L2SummonInstance)
-			{
-				L2Clan clan = ((L2SummonInstance)attacker).getOwner().getClan();
-				if (clan != null && clan.getClanId() == getCastle().getOwnerId())
-					return false;
-			}
-			else if (attacker instanceof L2PcInstance)
-			{
-				L2Clan clan = ((L2PcInstance)attacker).getClan();
-				if (clan != null && clan.getClanId() == getCastle().getOwnerId())
-					return false;
-			}
+			L2Clan clan = actingPlayer.getClan();
+			if (clan != null && clan.getClanId() == getCastle().getOwnerId())
+				return false;
 		}
 		return (isCastle || isFort);
 	}

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2FortManagerInstance.java

@@ -973,7 +973,7 @@ public class L2FortManagerInstance extends L2MerchantInstance
 		{
 			if (player.getClan() != null)
 			{
-				if (getFort().getSiege().getIsInProgress())
+				if (getFort().getZone().isActive())
 					return COND_BUSY_BECAUSE_OF_SIEGE; // Busy because of siege
 				else if (getFort().getOwnerClan() != null && getFort().getOwnerClan().getClanId() == player.getClanId()) // Clan owns fortress
 					return COND_OWNER; // Owner

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2FortSiegeNpcInstance.java

@@ -16,6 +16,7 @@ package com.l2jserver.gameserver.model.actor.instance;
 
 import java.util.StringTokenizer;
 
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2Clan;
 import com.l2jserver.gameserver.network.SystemMessageId;
 import com.l2jserver.gameserver.network.serverpackets.ActionFailed;
@@ -59,7 +60,13 @@ public class L2FortSiegeNpcInstance extends L2NpcWalkerInstance
 		{
 			if ((player.getClanPrivileges() & L2Clan.CP_CS_MANAGE_SIEGE) == L2Clan.CP_CS_MANAGE_SIEGE)
 			{
-				if (getFort().getSiege().registerAttacker(player, false))
+				if (System.currentTimeMillis() < TerritoryWarManager.getInstance().getTWStartTimeInMillis()
+						&& TerritoryWarManager.getInstance().getIsRegistrationOver())
+					player.sendPacket(new SystemMessage(SystemMessageId.NOT_SIEGE_REGISTRATION_TIME2));
+				else if (System.currentTimeMillis() > TerritoryWarManager.getInstance().getTWStartTimeInMillis()
+						&& TerritoryWarManager.getInstance().isTWChannelOpen())
+					player.sendPacket(new SystemMessage(SystemMessageId.NOT_SIEGE_REGISTRATION_TIME2));
+				else if (getFort().getSiege().registerAttacker(player, false))
 				{
 					SystemMessage sm = new SystemMessage(SystemMessageId.REGISTERED_TO_S1_FORTRESS_BATTLE);
 					sm.addString(getFort().getName());

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2FortWyvernManagerInstance.java

@@ -40,6 +40,6 @@ public class L2FortWyvernManagerInstance extends L2WyvernManagerInstance
 	@Override
 	public boolean isInSiege()
 	{
-		return getFort().getSiege().getIsInProgress();
+		return getFort().getZone().isActive();
 	}
 }

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2MercenaryManagerInstance.java

@@ -16,8 +16,8 @@ package com.l2jserver.gameserver.model.actor.instance;
 
 import com.l2jserver.Config;
 import com.l2jserver.gameserver.cache.HtmCache;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.actor.L2Npc;
-import com.l2jserver.gameserver.network.serverpackets.ExShowDominionRegistry;
 import com.l2jserver.gameserver.templates.chars.L2NpcTemplate;
 
 /**
@@ -26,36 +26,36 @@ import com.l2jserver.gameserver.templates.chars.L2NpcTemplate;
  */
 public class L2MercenaryManagerInstance extends L2Npc
 {
-    /**
-     * @param objectId
-     * @param template
-     */
-    public L2MercenaryManagerInstance(int objectId, L2NpcTemplate template)
-    {
-           super(objectId, template);
-           setInstanceType(InstanceType.L2MercenaryManagerInstance);
-    }
-
+	// private int[] TW_BADGE_IDS = { 13757, 13758, 13759, 13760, 13761, 13762, 13763, 13764, 13765 };
+	/**
+	 * @param objectId
+	 * @param template
+	 */
+	public L2MercenaryManagerInstance(int objectId, L2NpcTemplate template)
+	{
+		super(objectId, template);
+		setInstanceType(InstanceType.L2MercenaryManagerInstance);
+	}
+	
 	@Override
-	public void onBypassFeedback(L2PcInstance player, String command)
+	public void showChatWindow(L2PcInstance player)
 	{
-		if (command.equalsIgnoreCase("Territory"))
-		{
-			int castleId = getNpcId() - 36480;
-			player.sendPacket(new ExShowDominionRegistry(castleId));
-		}
+		if (player.getLevel() < 40 || player.getClassId().level() < 2)
+			super.showChatWindow(player, 2);
+		else if (TerritoryWarManager.getInstance().isTWInProgress())
+			super.showChatWindow(player, 10);
 		else
-			super.onBypassFeedback(player, command);
+			super.showChatWindow(player, 0);
 	}
-    
+	
 	@Override
 	public String getHtmlPath(int npcId, int val)
 	{
 		String temp = "";
 		if (val == 0)
-			temp = "data/html/mercmanager/MercenaryManager.htm";
+			temp = "data/html/mercmanager/" + npcId + ".htm";
 		else
-			temp = "data/html/mercmanager/MercenaryManager-" + val + ".htm";
+			temp = "data/html/mercmanager/" + npcId + "-" + val + ".htm";
 		
 		if (!Config.LAZY_CACHE)
 		{

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

@@ -86,6 +86,7 @@ import com.l2jserver.gameserver.instancemanager.InstanceManager;
 import com.l2jserver.gameserver.instancemanager.ItemsOnGroundManager;
 import com.l2jserver.gameserver.instancemanager.QuestManager;
 import com.l2jserver.gameserver.instancemanager.SiegeManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.BlockList;
 import com.l2jserver.gameserver.model.Elementals;
 import com.l2jserver.gameserver.model.FishData;
@@ -116,6 +117,7 @@ import com.l2jserver.gameserver.model.L2World;
 import com.l2jserver.gameserver.model.L2WorldRegion;
 import com.l2jserver.gameserver.model.MacroList;
 import com.l2jserver.gameserver.model.ShortCuts;
+import com.l2jserver.gameserver.model.TerritoryWard;
 import com.l2jserver.gameserver.model.TradeList;
 import com.l2jserver.gameserver.model.L2Skill.SkillTargetType;
 import com.l2jserver.gameserver.model.actor.L2Attackable;
@@ -1064,15 +1066,19 @@ public final class L2PcInstance extends L2Playable
 		}
 		if (getSiegeState() != 0)
 		{
-			result |= RelationChanged.RELATION_INSIEGE;
-			if (getSiegeState() != target.getSiegeState())
-				result |= RelationChanged.RELATION_ENEMY;
+			if (TerritoryWarManager.getInstance().getRegisteredTerritoryId(this) != 0)
+				result |= RelationChanged.RELATION_TERRITORY_WAR;
 			else
-				result |= RelationChanged.RELATION_ALLY;
-			if (getSiegeState() == 1)
-				result |= RelationChanged.RELATION_ATTACKER;
+			{
+				result |= RelationChanged.RELATION_INSIEGE;
+				if (getSiegeState() != target.getSiegeState())
+					result |= RelationChanged.RELATION_ENEMY;
+				else
+					result |= RelationChanged.RELATION_ALLY;
+				if (getSiegeState() == 1)
+					result |= RelationChanged.RELATION_ATTACKER;
+			}
 		}
-
 		if (getClan() != null && target.getClan() != null)
 		{
 			if (target.getPledgeType() != L2Clan.SUBUNIT_ACADEMY
@@ -3487,6 +3493,13 @@ public final class L2PcInstance extends L2Playable
             		fort.getSiege().announceToPlayer(new SystemMessage(SystemMessageId.C1_ACQUIRED_THE_FLAG), this.getName());
             	}
             }
+			// Territory Ward
+			else if (item.getItemId() >= 13560 && item.getItemId() <= 13568)
+			{
+				TerritoryWard ward = TerritoryWarManager.getInstance().getTerritoryWard(item.getItemId() - 13479);
+				if (ward != null)
+					ward.activate(this, item);
+			}
 		}
 	}
 
@@ -3593,6 +3606,13 @@ public final class L2PcInstance extends L2Playable
 						fort.getSiege().announceToPlayer(new SystemMessage(SystemMessageId.C1_ACQUIRED_THE_FLAG), this.getName());
 					}
 				}
+				// Territory Ward
+				else if (createdItem.getItemId() >= 13560 && createdItem.getItemId() <= 13568)
+				{
+					TerritoryWard ward = TerritoryWarManager.getInstance().getTerritoryWard(createdItem.getItemId() - 13479);
+					if (ward != null)
+						ward.activate(this, createdItem);
+				}
 			}
 		}
 	}
@@ -5407,7 +5427,10 @@ public final class L2PcInstance extends L2Playable
 			}
 			else if (isCombatFlagEquipped())
 			{
-				FortSiegeManager.getInstance().dropCombatFlag(this);
+				if (TerritoryWarManager.getInstance().isTWInProgress())
+					TerritoryWarManager.getInstance().dropCombatFlag(this, true);
+				else
+					FortSiegeManager.getInstance().dropCombatFlag(this);
 			}
 			else
 			{
@@ -6523,6 +6546,9 @@ public final class L2PcInstance extends L2Playable
         // Don't allow disarming a cursed weapon
         if (isCursedWeaponEquipped()) return false;
 
+        // Don't allow disarming a Combat Flag or Territory Ward
+        if (isCombatFlagEquipped()) return false;
+
         // Unequip the weapon
         L2ItemInstance wpn = getInventory().getPaperdollItem(Inventory.PAPERDOLL_RHAND);
         if (wpn == null) wpn = getInventory().getPaperdollItem(Inventory.PAPERDOLL_LRHAND);
@@ -8838,6 +8864,19 @@ public final class L2PcInstance extends L2Playable
 				return false;
 			}
 
+			if (target.getActingPlayer() != null && getSiegeState() > 0 && isInsideZone(L2Character.ZONE_SIEGE)
+					&& target.getActingPlayer().getSiegeState() == getSiegeState()
+					&& target.getActingPlayer() != this && target.getActingPlayer().getSiegeSide() == getSiegeSide())
+			{
+				// 
+				if (TerritoryWarManager.getInstance().isTWInProgress())
+					sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_ATTACK_A_MEMBER_OF_THE_SAME_TERRITORY));
+				else
+					sendPacket(new SystemMessage(SystemMessageId.FORCED_ATTACK_IS_IMPOSSIBLE_AGAINST_SIEGE_SIDE_TEMPORARY_ALLIED_MEMBERS));
+				sendPacket(ActionFailed.STATIC_PACKET);
+				return false;
+			}
+
             // Check if the target is attackable
             if (!target.isAttackable() && !getAccessLevel().allowPeaceAttack())
 			{
@@ -9042,9 +9081,10 @@ public final class L2PcInstance extends L2Playable
 				}
 		}
 
+		// TODO: Unhardcode skillId 844 which is the outpost construct skill
 		if ((sklTargetType == SkillTargetType.TARGET_HOLY && !checkIfOkToCastSealOfRule(CastleManager.getInstance().getCastle(this), false, skill))
 				|| (sklTargetType == SkillTargetType.TARGET_FLAGPOLE && !checkIfOkToCastFlagDisplay(FortManager.getInstance().getFort(this), false, skill))
-				|| (sklType == L2SkillType.SIEGEFLAG && !L2SkillSiegeFlag.checkIfOkToPlaceFlag(this, false))
+				|| (sklType == L2SkillType.SIEGEFLAG && !L2SkillSiegeFlag.checkIfOkToPlaceFlag(this, false, skill.getId() == 844))
 				|| (sklType == L2SkillType.STRSIEGEASSAULT && !checkIfOkToUseStriderSiegeAssault())
 				|| (sklType == L2SkillType.SUMMON_FRIEND && !(checkSummonerStatus(this) && checkSummonTargetStatus(target, this))))
 		{
@@ -11512,6 +11552,10 @@ public final class L2PcInstance extends L2Playable
 					destroyItem("CombatFlag", getInventory().getItemByItemId(9819), null, true);
 				}
 			}
+			else if (isCombatFlagEquipped())
+			{
+				TerritoryWarManager.getInstance().dropCombatFlag(this, false);
+			}
 		}
 		catch (Exception e)
 		{
@@ -12697,6 +12741,12 @@ public final class L2PcInstance extends L2Playable
 		return _cursedWeaponEquippedId;
 	}
 	
+	@Override
+	public boolean isAttackingDisabled()
+	{
+		return (super.isAttackingDisabled() || _combatFlagEquippedId);
+	}
+	
 	public boolean isCombatFlagEquipped()
     {
         return _combatFlagEquippedId ;
@@ -13324,6 +13374,12 @@ public final class L2PcInstance extends L2Playable
 		}
 
 		if (targetChar.inObserverMode())
+		{
+			summonerChar.sendPacket(new SystemMessage(SystemMessageId.C1_STATE_FORBIDS_SUMMONING).addCharName(targetChar));
+			return false;
+		}
+
+		if (targetChar.isCombatFlagEquipped())
 		{
 			summonerChar.sendPacket(new SystemMessage(SystemMessageId.YOUR_TARGET_IS_IN_AN_AREA_WHICH_BLOCKS_SUMMONING));
 			return false;
@@ -13946,7 +14002,7 @@ public final class L2PcInstance extends L2Playable
     		sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_USE_MY_TELEPORTS_DURING_A_BATTLE));
     		return false;
     	}
-    	else if (this.isInSiege())
+    	else if (this.isInSiege() || this.getSiegeState() != 0)
     	{
     		sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_USE_MY_TELEPORTS_WHILE_PARTICIPATING));
     		return false;

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2SiegeFlagInstance.java

@@ -18,6 +18,7 @@ import com.l2jserver.gameserver.ThreadPoolManager;
 import com.l2jserver.gameserver.ai.CtrlIntention;
 import com.l2jserver.gameserver.instancemanager.FortSiegeManager;
 import com.l2jserver.gameserver.instancemanager.SiegeManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2Clan;
 import com.l2jserver.gameserver.model.L2SiegeClan;
 import com.l2jserver.gameserver.model.L2Skill;
@@ -41,11 +42,31 @@ public class L2SiegeFlagInstance extends L2Npc
     private final boolean _isAdvanced;
     private boolean _canTalk;
 
-    public L2SiegeFlagInstance(L2PcInstance player, int objectId, L2NpcTemplate template, boolean advanced)
+    public L2SiegeFlagInstance(L2PcInstance player, int objectId, L2NpcTemplate template, boolean advanced, boolean outPost)
 	{
 		super(objectId, template);
 		setInstanceType(InstanceType.L2SiegeFlagInstance);
 		
+		if (TerritoryWarManager.getInstance().isTWInProgress())
+		{
+			_clan = player.getClan();
+			_player = player;
+			_canTalk = false;
+			if (_clan == null)
+				deleteMe();
+			if (outPost)
+			{
+				_isAdvanced = false;
+				setIsInvul(true);
+			}
+			else
+			{
+				_isAdvanced = advanced;
+				setIsInvul(false);
+			}
+			getStatus();
+			return;
+		}
 		_clan = player.getClan();
 		_player = player;
 		_canTalk = true;
@@ -82,13 +103,13 @@ public class L2SiegeFlagInstance extends L2Npc
     @Override
 	public boolean isAttackable()
     {
-        return true;
+        return !isInvul();
     }
 
 	@Override
 	public boolean isAutoAttackable(L2Character attacker)
 	{
-		return true;
+		return !isInvul();
 	}
 
     @Override
@@ -102,6 +123,8 @@ public class L2SiegeFlagInstance extends L2Npc
             if (sc != null)
             	sc.removeFlag(this);
     	}
+    	else if (_clan != null)
+    		TerritoryWarManager.getInstance().removeClanFlag(_clan);
         return true;
     }
 

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2TeleporterInstance.java

@@ -227,6 +227,11 @@ public final class L2TeleporterInstance extends L2Npc
 				player.sendMessage("Go away, you're not welcome here.");
 				return;
 			}
+			else if (player.isCombatFlagEquipped())
+			{
+				player.sendMessage("You can't port with a Combat Flag or Territory Ward!");
+				return;
+			}
 			else if (list.getIsForNoble() && !player.isNoble())
 			{
 				String filename = "data/html/teleporter/nobleteleporter-no.htm";

L2_GameServer/java/com/l2jserver/gameserver/model/actor/instance/L2TerritoryWardInstance.java

@@ -0,0 +1,139 @@
+/*
+ * This program 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.
+ * 
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+ * FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
+ * details.
+ * 
+ * You should have received a copy of the GNU General Public License along with
+ * this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.l2jserver.gameserver.model.actor.instance;
+
+import com.l2jserver.gameserver.ai.CtrlIntention;
+import com.l2jserver.gameserver.instancemanager.CastleManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
+import com.l2jserver.gameserver.model.actor.L2Attackable;
+import com.l2jserver.gameserver.model.actor.L2Character;
+import com.l2jserver.gameserver.model.entity.Castle;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.ActionFailed;
+import com.l2jserver.gameserver.network.serverpackets.MyTargetSelected;
+import com.l2jserver.gameserver.network.serverpackets.StatusUpdate;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+import com.l2jserver.gameserver.network.serverpackets.ValidateLocation;
+import com.l2jserver.gameserver.templates.chars.L2NpcTemplate;
+
+public final class L2TerritoryWardInstance extends L2Attackable
+{
+	private Castle _castle = null; // the castle which owns this Ward
+	
+	public L2TerritoryWardInstance(int objectId, L2NpcTemplate template)
+	{
+		super(objectId, template);
+		
+		disableCoreAI(true);
+	}
+	
+	@Override
+	public boolean isAutoAttackable(L2Character attacker)
+	{
+		if (isInvul())
+			return false;
+		else if (_castle != null && _castle.getZone().isActive())
+		{
+			L2PcInstance actingPlayer = attacker.getActingPlayer();
+			if (actingPlayer != null && actingPlayer.getSiegeSide() != 0
+					&& !TerritoryWarManager.getInstance().isAllyField(actingPlayer, _castle.getCastleId()))
+				return true;
+		}
+		return false;
+	}
+	
+	@Override
+	public boolean hasRandomAnimation()
+	{
+		return false;
+	}
+	
+	@Override
+	public void onSpawn()
+	{
+		super.onSpawn();
+
+		_castle = CastleManager.getInstance().getCastle(getX(), getY(), getZ());
+		if (_castle == null)
+			_log.warning("L2TerritoryWardInstance(" + getName() + ") spawned outside Castle Zone!");
+	}
+	
+	@Override
+	public boolean doDie(L2Character killer)
+	{
+		// Kill the L2NpcInstance (the corpse disappeared after 7 seconds)
+		if (!super.doDie(killer) || _castle == null || !TerritoryWarManager.getInstance().isTWInProgress())
+			return false;
+
+		if (killer instanceof L2PcInstance)
+		{
+			if (((L2PcInstance)killer).getSiegeSide() > 0 && !((L2PcInstance)killer).isCombatFlagEquipped())
+				((L2PcInstance)killer).addItem("Pickup", getNpcId() - 23012, 1, null, false);
+			else
+				TerritoryWarManager.getInstance().getTerritoryWard(getNpcId() - 36491).spawnMe();
+			SystemMessage sm = new SystemMessage(SystemMessageId.THE_S1_WARD_HAS_BEEN_DESTROYED);
+			sm.addString(this.getName().replaceAll(" Ward", ""));
+			sm.addPcName((L2PcInstance)killer);
+			TerritoryWarManager.getInstance().announceToParticipants(sm, 0, 0);
+		}
+		else
+			TerritoryWarManager.getInstance().getTerritoryWard(getNpcId() - 36491).spawnMe();
+		decayMe();
+		return true;
+	}
+
+	@Override
+	public void onForcedAttack(L2PcInstance player)
+	{
+		onAction(player);
+	}
+
+	@Override
+	public void onAction(L2PcInstance player, boolean interact)
+	{
+		if (player == null || !canTarget(player))
+			return;
+
+			// Check if the L2PcInstance already target the L2NpcInstance
+		if (this != player.getTarget())
+		{
+			// Set the target of the L2PcInstance player
+			player.setTarget(this);
+
+			// Send a Server->Client packet MyTargetSelected to the L2PcInstance player
+			MyTargetSelected my = new MyTargetSelected(getObjectId(), player.getLevel() - getLevel());
+			player.sendPacket(my);
+
+			// Send a Server->Client packet StatusUpdate of the L2NpcInstance to the L2PcInstance to update its HP bar
+			StatusUpdate su = new StatusUpdate(getObjectId());
+			su.addAttribute(StatusUpdate.CUR_HP, (int)getStatus().getCurrentHp() );
+			su.addAttribute(StatusUpdate.MAX_HP, getMaxHp() );
+			player.sendPacket(su);
+
+			// Send a Server->Client packet ValidateLocation to correct the L2NpcInstance position and heading on the client
+			player.sendPacket(new ValidateLocation(this));
+		}
+		else if (interact)
+		{
+			if (isAutoAttackable(player) && Math.abs(player.getZ() - getZ()) < 100)
+				player.getAI().setIntention(CtrlIntention.AI_INTENTION_ATTACK, this);
+			else
+			{
+				// Send a Server->Client ActionFailed to the L2PcInstance in order to avoid that the client wait another packet
+				player.sendPacket(ActionFailed.STATIC_PACKET);
+			}
+		}
+	}
+}

L2_GameServer/java/com/l2jserver/gameserver/model/actor/knownlist/DefenderKnownList.java

@@ -15,6 +15,7 @@
 package com.l2jserver.gameserver.model.actor.knownlist;
 
 import com.l2jserver.gameserver.ai.CtrlIntention;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.actor.L2Summon;
 import com.l2jserver.gameserver.model.actor.instance.L2DefenderInstance;
@@ -57,7 +58,8 @@ public class DefenderKnownList extends AttackableKnownList
 
 			// Check if player is an enemy of this defender npc
 			if (player != null && ((player.getSiegeState() == 2 && !player.isRegisteredOnThisSiegeField(activeSiegeId))
-					|| player.getSiegeState() < 2))
+					|| (player.getSiegeState() == 1 && !TerritoryWarManager.getInstance().isAllyField(player, activeSiegeId))
+					|| player.getSiegeState() == 0))
 			{
 				if (getActiveChar().getAI().getIntention() == CtrlIntention.AI_INTENTION_IDLE)
 					getActiveChar().getAI().setIntention(CtrlIntention.AI_INTENTION_ACTIVE, null);

L2_GameServer/java/com/l2jserver/gameserver/model/entity/Castle.java

@@ -37,9 +37,11 @@ import com.l2jserver.gameserver.datatables.ResidentialSkillTable;
 import com.l2jserver.gameserver.instancemanager.CastleManager;
 import com.l2jserver.gameserver.instancemanager.CastleManorManager;
 import com.l2jserver.gameserver.instancemanager.FortManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.instancemanager.ZoneManager;
 import com.l2jserver.gameserver.instancemanager.CastleManorManager.CropProcure;
 import com.l2jserver.gameserver.instancemanager.CastleManorManager.SeedProduction;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager.Territory;
 import com.l2jserver.gameserver.model.L2Clan;
 import com.l2jserver.gameserver.model.L2Manor;
 import com.l2jserver.gameserver.model.L2Object;
@@ -510,6 +512,11 @@ public class Castle
 					e.printStackTrace();
 				}
 				oldOwner.setHasCastle(0); // Unset has castle flag for old owner
+				for (L2PcInstance member : oldOwner.getOnlineMembers(0))
+				{
+					removeResidentialSkills(member);
+					member.sendSkillList();
+				}
 			}
 		}
 		
@@ -522,7 +529,9 @@ public class Castle
 		
 		if (getSiege().getIsInProgress()) // If siege in progress
 			getSiege().midVictory(); // Mid victory phase of siege
-			
+		
+		TerritoryWarManager.getInstance().getTerritory(_castleId).setOwnerClan(clan);
+		
 		for (L2PcInstance member : clan.getOnlineMembers(0))
 		{
 			giveResidentialSkills(member);
@@ -1621,6 +1630,12 @@ public class Castle
 			for (L2Skill sk : _residentialSkills)
 				player.addSkill(sk, false);
 		}
+		Territory territory = TerritoryWarManager.getInstance().getTerritory(getCastleId());
+		if (territory != null && territory.getOwnedWardIds().contains(getCastleId() + 80))
+			for(int wardId : territory.getOwnedWardIds())
+				if (ResidentialSkillTable.getInstance().getSkills(wardId) != null)
+					for (L2Skill sk : ResidentialSkillTable.getInstance().getSkills(wardId))
+						player.addSkill(sk, false);
 	}
 	
 	public void removeResidentialSkills(L2PcInstance player)
@@ -1630,6 +1645,11 @@ public class Castle
 			for (L2Skill sk : _residentialSkills)
 				player.removeSkill(sk, false);
 		}
+		if (TerritoryWarManager.getInstance().getTerritory(getCastleId()) != null)
+			for(int wardId : TerritoryWarManager.getInstance().getTerritory(getCastleId()).getOwnedWardIds())
+				if (ResidentialSkillTable.getInstance().getSkills(wardId) != null)
+					for (L2Skill sk : ResidentialSkillTable.getInstance().getSkills(wardId))
+						player.removeSkill(sk, false);
 	}
 	
 	/**

L2_GameServer/java/com/l2jserver/gameserver/model/quest/Quest.java

@@ -70,7 +70,7 @@ public class Quest extends ManagedScript
 	private final String _name;
 	private final String _descr;
 	private final byte _initialState = State.CREATED;
-	private boolean _onEnterWorld = false;
+	protected boolean _onEnterWorld = false;
 	// NOTE: questItemIds will be overridden by child classes.  Ideally, it should be
 	// protected instead of public.  However, quest scripts written in Jython will
 	// have trouble with protected, as Jython only knows private and public...

L2_GameServer/java/com/l2jserver/gameserver/model/quest/QuestState.java

@@ -185,6 +185,17 @@ public final class QuestState
 		return state;
 	}
 
+	public Object setStateAndNotSave(byte state)
+	{
+		// set new state if it is not already in that state
+		if (_state != state)
+		{
+			_state = state;
+			getPlayer().sendPacket(new QuestList());
+		}
+		return state;
+	}
+
 	/**
 	 * Add parameter used in quests.
 	 * @param var : String pointing out the name of the variable for quest

L2_GameServer/java/com/l2jserver/gameserver/model/zone/type/L2CastleZone.java

@@ -40,6 +40,7 @@ public class L2CastleZone extends L2SpawnZone
 	private int _castleId;
 	private Castle _castle = null;
 	private boolean _isActiveSiege = false;
+	private static final int DISMOUNT_DELAY = 5;
 	
 	public L2CastleZone(int id)
 	{
@@ -76,6 +77,11 @@ public class L2CastleZone extends L2SpawnZone
 						((L2PcInstance) character).startFameTask(Config.CASTLE_ZONE_FAME_TASK_FREQUENCY * 1000, Config.CASTLE_ZONE_FAME_AQUIRE_POINTS);
 					}
 					((L2PcInstance) character).sendPacket(new SystemMessage(SystemMessageId.ENTERED_COMBAT_ZONE));
+					if (!Config.ALLOW_WYVERN_DURING_SIEGE && ((L2PcInstance) character).getMountType() == 2)
+					{
+						character.sendPacket(new SystemMessage(SystemMessageId.AREA_CANNOT_BE_ENTERED_WHILE_MOUNTED_WYVERN));
+						((L2PcInstance) character).enteredNoLanding(DISMOUNT_DELAY);
+					}
 				}
 			}
 			character.setInsideZone(L2Character.ZONE_CASTLE, true);
@@ -93,6 +99,10 @@ public class L2CastleZone extends L2SpawnZone
 				if (character instanceof L2PcInstance)
 				{
 					((L2PcInstance) character).sendPacket(new SystemMessage(SystemMessageId.LEFT_COMBAT_ZONE));
+					if (((L2PcInstance) character).getMountType() == 2)
+					{
+						((L2PcInstance) character).exitedNoLanding();
+					}
 					// Set pvp flag
 					if (((L2PcInstance) character).getPvpFlag() == 0)
 						((L2PcInstance) character).startPvPFlag();
@@ -168,6 +178,10 @@ public class L2CastleZone extends L2SpawnZone
 					{
 						((L2PcInstance) character).sendPacket(new SystemMessage(SystemMessageId.LEFT_COMBAT_ZONE));
 						((L2PcInstance) character).stopFameTask();
+						if (((L2PcInstance) character).getMountType() == 2)
+						{
+							((L2PcInstance) character).exitedNoLanding();
+						}
 					}
 					if (character instanceof L2SiegeSummonInstance)
 					{

L2_GameServer/java/com/l2jserver/gameserver/model/zone/type/L2FortZone.java

@@ -42,6 +42,7 @@ public class L2FortZone extends L2SpawnZone
 	private int _fortId;
 	private Fort _fort = null;
 	private boolean _isActiveSiege = false;
+	private static final int DISMOUNT_DELAY = 5;
 	
 	public L2FortZone(int id)
 	{
@@ -77,6 +78,11 @@ public class L2FortZone extends L2SpawnZone
 					((L2PcInstance) character).startFameTask(Config.FORTRESS_ZONE_FAME_TASK_FREQUENCY * 1000, Config.FORTRESS_ZONE_FAME_AQUIRE_POINTS);
 					((L2PcInstance) character).setIsInSiege(true);
 				}
+				if (!Config.ALLOW_WYVERN_DURING_SIEGE && ((L2PcInstance) character).getMountType() == 2)
+				{
+					character.sendPacket(new SystemMessage(SystemMessageId.AREA_CANNOT_BE_ENTERED_WHILE_MOUNTED_WYVERN));
+					((L2PcInstance) character).enteredNoLanding(DISMOUNT_DELAY);
+				}
 			}
 		}
 	}
@@ -94,6 +100,10 @@ public class L2FortZone extends L2SpawnZone
 			{
 				((L2PcInstance) character).sendPacket(new SystemMessage(SystemMessageId.LEFT_COMBAT_ZONE));
 
+				if (((L2PcInstance) character).getMountType() == 2)
+				{
+					((L2PcInstance) character).exitedNoLanding();
+				}
 				// Set pvp flag
 				if (((L2PcInstance) character).getPvpFlag() == 0)
 					((L2PcInstance) character).startPvPFlag();
@@ -180,6 +190,10 @@ public class L2FortZone extends L2SpawnZone
 					{
 						((L2PcInstance) character).sendPacket(new SystemMessage(SystemMessageId.LEFT_COMBAT_ZONE));
 						((L2PcInstance) character).stopFameTask();
+						if (((L2PcInstance) character).getMountType() == 2)
+						{
+							((L2PcInstance) character).exitedNoLanding();
+						}
 					}
 					if (character instanceof L2SiegeSummonInstance)
 					{

L2_GameServer/java/com/l2jserver/gameserver/network/L2GamePacketHandler.java

@@ -977,6 +977,7 @@ public final class L2GamePacketHandler implements IPacketHandler<L2GameClient>,
 		                    	break;
 		                    case 0x57:
 		                    	// RequestJoinDominionWar
+		                    	msg = new RequestJoinDominionWar();
 		                    	break;
 		                    case 0x58:
 		                    	msg = new RequestDominionInfo();

L2_GameServer/java/com/l2jserver/gameserver/network/SystemMessageId.java

@@ -13892,6 +13892,24 @@ public enum SystemMessageId
 	*/
 	YOU_HAVE_NO_OPEN_MY_TELEPORTS_SLOTS(2398),
 	
+	/**
+	* ID: 2936<br>
+	* Message: The disguise scroll cannot be used because it is meant for use in a different territory.
+	*/
+	THE_DISGUISE_SCROLL_MEANT_FOR_DIFFERENT_TERRITORY(2936),
+	
+	/**
+	* ID: 2937<br>
+	* Message: A territory owning clan member cannot use a disguise scroll.
+	*/
+	TERRITORY_OWNING_CLAN_CANNOT_USE_DISGUISE_SCROLL(2937),
+	
+	/**
+	* ID: 2955<br>
+	* Message: The territory war exclusive disguise and transformation can be used 20 minutes before the start of the territory war to 10 minutes after its end.
+	*/
+	TERRITORY_WAR_SCROLL_CAN_NOT_USED_NOW(2955),
+	
 	/**
 	* ID: 2400<br>
 	* Message: Instant Zone currently in use: $s1
@@ -14018,6 +14036,18 @@ public enum SystemMessageId
 	*/
 	YOU_CANNOT_MOUNT_NOT_MEET_REQUEIREMENTS(2727),
 	
+	/**
+	* ID: 2750<br>
+	* Message: The $s1 ward has been destroyed! $c2 now has the territory ward.
+	*/
+	THE_S1_WARD_HAS_BEEN_DESTROYED(2750),
+	
+	/**
+	* ID: 2751<br>
+	* Message: The character that acquired $s1 ward has been killed.
+	*/
+	THE_CHAR_THAT_ACQUIRED_S1_WARD_HAS_BEEN_KILLED(2751),
+
 	/**
 	* ID: 2795<br>
 	* Message: You've already requested a territory war in another territory elsewhere.
@@ -14054,6 +14084,18 @@ public enum SystemMessageId
 	*/
 	S1_SECONDS_TO_THE_END_OF_TERRITORY_WAR(2900),
 	
+	/**
+	* ID: 2901<br>
+	* Message: You cannot force attack a member of the same territory.
+	*/
+	YOU_CANNOT_ATTACK_A_MEMBER_OF_THE_SAME_TERRITORY(2901),
+	
+	/**
+	* ID: 2902<br>
+	* Message: You've acquired the ward. Move quickly to your forces' outpost.
+	*/
+	YOU_VE_ACQUIRED_THE_WARD(2902),
+	
 	/**
 	* ID: 2903<br>
 	* Message: Territory war has begun.
@@ -14072,6 +14114,12 @@ public enum SystemMessageId
 	 */
 	YOU_REQUESTED_C1_TO_BE_FRIEND(2911),
 	
+	/**
+	 * ID: 2913
+	 * Message: Clan $s1 has succeeded in capturing $s2's territory ward.
+	 */
+	CLAN_S1_HAS_SUCCEDED_IN_CAPTURING_S2_TERRITORY_WARD(2913),
+	
 	/**
 	* ID: 2914<br>
 	* Message: The territory war will begin in 20 minutes! Territory related functions (ie: battlefield channel, Disguise Scrolls, Transformations, etc...) can now be used.

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/EnterWorld.java

@@ -42,6 +42,7 @@ import com.l2jserver.gameserver.instancemanager.MailManager;
 import com.l2jserver.gameserver.instancemanager.PetitionManager;
 import com.l2jserver.gameserver.instancemanager.QuestManager;
 import com.l2jserver.gameserver.instancemanager.SiegeManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2Clan;
 import com.l2jserver.gameserver.model.L2ItemInstance;
 import com.l2jserver.gameserver.model.L2Object;
@@ -263,6 +264,13 @@ public class EnterWorld extends L2GameClientPacket
 			showClanNotice = activeChar.getClan().isNoticeEnabled();
 		}
 
+		if (TerritoryWarManager.getInstance().getRegisteredTerritoryId(activeChar) > 0)
+		{
+			if (TerritoryWarManager.getInstance().isTWInProgress())
+				activeChar.setSiegeState((byte)1);
+			activeChar.setSiegeSide(TerritoryWarManager.getInstance().getRegisteredTerritoryId(activeChar));
+		}
+
 		// Updating Seal of Strife Buff/Debuff 
 		if (SevenSigns.getInstance().isSealValidationPeriod() && SevenSigns.getInstance().getSealOwner(SevenSigns.SEAL_STRIFE) != SevenSigns.CABAL_NULL)
 		{

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestActionUse.java

@@ -23,10 +23,12 @@ import com.l2jserver.gameserver.ai.L2SummonAI;
 import com.l2jserver.gameserver.datatables.PetSkillsTable;
 import com.l2jserver.gameserver.datatables.SkillTable;
 import com.l2jserver.gameserver.instancemanager.CastleManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2CharPosition;
 import com.l2jserver.gameserver.model.L2ManufactureList;
 import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.L2Skill;
+import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.L2Summon;
 import com.l2jserver.gameserver.model.actor.instance.L2DoorInstance;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
@@ -169,6 +171,19 @@ public final class RequestActionUse extends L2GameClientPacket
 						return;
 					}
 					
+					if (target.getActingPlayer() != null && pet.getOwner().getSiegeState() > 0 && pet.getOwner().isInsideZone(L2Character.ZONE_SIEGE)
+							&& target.getActingPlayer().getSiegeState() == pet.getOwner().getSiegeState()
+							&& target.getActingPlayer() != pet.getOwner() && target.getActingPlayer().getSiegeSide() == pet.getOwner().getSiegeSide())
+					{
+						// 
+						if (TerritoryWarManager.getInstance().isTWInProgress())
+							sendPacket(new SystemMessage(SystemMessageId.YOU_CANNOT_ATTACK_A_MEMBER_OF_THE_SAME_TERRITORY));
+						else
+							sendPacket(new SystemMessage(SystemMessageId.FORCED_ATTACK_IS_IMPOSSIBLE_AGAINST_SIEGE_SIDE_TEMPORARY_ALLIED_MEMBERS));
+						sendPacket(ActionFailed.STATIC_PACKET);
+						return;
+					}
+					
 					if (!activeChar.getAccessLevel().allowPeaceAttack() && activeChar.isInsidePeaceZone(pet, target))
 					{
 						activeChar.sendPacket(new SystemMessage(SystemMessageId.TARGET_IN_PEACEZONE));

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestDominionInfo.java

@@ -15,6 +15,7 @@
 package com.l2jserver.gameserver.network.clientpackets;
 
 import com.l2jserver.gameserver.network.serverpackets.ExReplyDominionInfo;
+import com.l2jserver.gameserver.network.serverpackets.ExShowOwnthingPos;
 
 /**
  *
@@ -47,5 +48,6 @@ public class RequestDominionInfo extends L2GameClientPacket
 	protected void runImpl()
 	{
 		sendPacket(new ExReplyDominionInfo());
+		sendPacket(new ExShowOwnthingPos());
 	}
 }

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestJoinDominionWar.java

@@ -0,0 +1,125 @@
+/*
+ * This program 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.
+ * 
+ * This program 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.network.clientpackets;
+
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
+import com.l2jserver.gameserver.model.L2Clan;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.network.SystemMessageId;
+import com.l2jserver.gameserver.network.serverpackets.ExShowDominionRegistry;
+import com.l2jserver.gameserver.network.serverpackets.SystemMessage;
+
+/**
+ *
+ * @author Gigiikun
+ */
+public final class RequestJoinDominionWar extends L2GameClientPacket
+{
+	private static final String _C__57_RequestJoinDominionWar = "[C] 57 RequestJoinDominionWar";
+	// private static Logger _log = Logger.getLogger(RequestJoinDominionWar.class.getName());
+
+	private int _territoryId;
+	private int _isClan;
+	private int _isJoining;
+
+	@Override
+	protected void readImpl()
+	{
+		_territoryId = readD();
+		_isClan = readD();
+		_isJoining = readD();
+	}
+
+	@Override
+	protected void runImpl()
+	{
+		L2PcInstance activeChar = getClient().getActiveChar();
+		if (activeChar == null) return;
+		L2Clan clan = activeChar.getClan();
+		int castleId = _territoryId - 80;
+		
+		if (TerritoryWarManager.getInstance().getIsRegistrationOver())
+		{
+			activeChar.sendPacket(new SystemMessage(SystemMessageId.NOT_TERRITORY_REGISTRATION_PERIOD));
+			return;
+		}
+		else if (clan != null && TerritoryWarManager.getInstance().getTerritory(castleId).getOwnerClan() == clan)
+		{
+			activeChar.sendPacket(new SystemMessage(SystemMessageId.THE_TERRITORY_OWNER_CLAN_CANNOT_PARTICIPATE_AS_MERCENARIES));
+			return;
+		}
+		
+		if (_isClan == 0x01)
+		{
+			if ((activeChar.getClanPrivileges() & L2Clan.CP_CS_MANAGE_SIEGE) != L2Clan.CP_CS_MANAGE_SIEGE)
+			{
+				activeChar.sendPacket(new SystemMessage(SystemMessageId.YOU_ARE_NOT_AUTHORIZED_TO_DO_THAT));
+				return;
+			}
+			
+			if (clan == null) return;
+			
+			if (_isJoining == 1)
+			{
+				if (System.currentTimeMillis() < clan.getDissolvingExpiryTime())
+				{
+					activeChar.sendPacket(new SystemMessage(SystemMessageId.CANT_PARTICIPATE_IN_SIEGE_WHILE_DISSOLUTION_IN_PROGRESS));
+					return;
+				}
+				else if (TerritoryWarManager.getInstance().checkIsRegistered(-1, clan))
+				{
+					activeChar.sendPacket(new SystemMessage(SystemMessageId.YOU_ALREADY_REQUESTED_TW_REGISTRATION));
+					return;
+				}
+				TerritoryWarManager.getInstance().registerClan(castleId, clan);
+			}
+			else
+				TerritoryWarManager.getInstance().removeClan(castleId, clan);
+		}
+		else
+		{
+			if (activeChar.getLevel() < 40 || activeChar.getClassId().level() < 2)
+			{
+				// TODO: punish player
+				return;
+			}
+			if (_isJoining == 1)
+			{
+				if (TerritoryWarManager.getInstance().checkIsRegistered(-1, activeChar.getObjectId()))
+				{
+					activeChar.sendPacket(new SystemMessage(SystemMessageId.YOU_ALREADY_REQUESTED_TW_REGISTRATION));
+					return;
+				}
+				else if (clan != null &&
+						TerritoryWarManager.getInstance().checkIsRegistered(-1, clan))
+				{
+					activeChar.sendPacket(new SystemMessage(SystemMessageId.YOU_ALREADY_REQUESTED_TW_REGISTRATION));
+					return;
+				}
+				TerritoryWarManager.getInstance().registerMerc(castleId, activeChar);
+			}
+			else
+				TerritoryWarManager.getInstance().removeMerc(castleId, activeChar);
+		}
+		activeChar.sendPacket(new ExShowDominionRegistry(castleId, activeChar));
+	}
+
+	@Override
+	public String getType()
+	{
+		return _C__57_RequestJoinDominionWar;
+	}
+}

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestRestartPoint.java

@@ -21,9 +21,11 @@ import com.l2jserver.gameserver.datatables.MapRegionTable;
 import com.l2jserver.gameserver.instancemanager.CastleManager;
 import com.l2jserver.gameserver.instancemanager.ClanHallManager;
 import com.l2jserver.gameserver.instancemanager.FortManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2SiegeClan;
 import com.l2jserver.gameserver.model.Location;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.model.actor.instance.L2SiegeFlagInstance;
 import com.l2jserver.gameserver.model.entity.Castle;
 import com.l2jserver.gameserver.model.entity.ClanHall;
 import com.l2jserver.gameserver.model.entity.Fort;
@@ -144,13 +146,14 @@ public final class RequestRestartPoint extends L2GameClientPacket
 					L2SiegeClan siegeClan = null;
 					castle = CastleManager.getInstance().getCastle(activeChar);
 					fort = FortManager.getInstance().getFort(activeChar);
+					L2SiegeFlagInstance flag = TerritoryWarManager.getInstance().getFlagForClan(activeChar.getClan());
 
 					if (castle != null && castle.getSiege().getIsInProgress())
 						siegeClan = castle.getSiege().getAttackerClan(activeChar.getClan());
 					else if (fort != null && fort.getSiege().getIsInProgress())
 						siegeClan = fort.getSiege().getAttackerClan(activeChar.getClan());
 
-					if (siegeClan == null || siegeClan.getFlag().isEmpty())
+					if ((siegeClan == null || siegeClan.getFlag().isEmpty()) && flag == null)
 					{
 						_log.warning("Player ["+activeChar.getName()+"] called RestartPointPacket - To Siege HQ and he doesn't have Siege HQ!");
 						return;

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/RequestUnEquipItem.java

@@ -67,7 +67,7 @@ public class RequestUnEquipItem extends L2GameClientPacket
 			return;
 		}
 		// Prevent of unequiping a cursed weapon
-		if (_slot == L2Item.SLOT_LR_HAND && activeChar.isCursedWeaponEquipped())
+		if (_slot == L2Item.SLOT_LR_HAND && (activeChar.isCursedWeaponEquipped() || activeChar.isCombatFlagEquipped()))
 		{
 			// Message ?
 			return;

L2_GameServer/java/com/l2jserver/gameserver/network/clientpackets/UseItem.java

@@ -83,7 +83,7 @@ public final class UseItem extends L2GameClientPacket
 		L2PcInstance activeChar = getClient().getActiveChar();
 		if (activeChar == null)
             return;
-
+		
 		// Flood protect UseItem
 		if (!activeChar.getFloodProtectors().getUseItem().tryPerformAction("use item"))
 			return;
@@ -104,7 +104,7 @@ public final class UseItem extends L2GameClientPacket
 			L2ItemInstance item = activeChar.getInventory().getItemByObjectId(_objectId);
 			if (item == null)
                 return;
-
+			
 			if (item.isWear())
 			{
 				// No unequipping wear-items
@@ -344,6 +344,8 @@ public final class UseItem extends L2GameClientPacket
                 // Equip or unEquip
                 if (FortSiegeManager.getInstance().isCombat(item.getItemId()))
                 	return;	//no message
+                else if (activeChar.isCombatFlagEquipped())
+                	return;
 
                 activeChar.useEquippableItem(item, true);
 			}

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/CharInfo.java

@@ -19,6 +19,7 @@ import java.util.logging.Logger;
 import com.l2jserver.Config;
 import com.l2jserver.gameserver.datatables.NpcTable;
 import com.l2jserver.gameserver.instancemanager.CursedWeaponsManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.model.itemcontainer.Inventory;
 import com.l2jserver.gameserver.skills.AbnormalEffect;
@@ -59,34 +60,38 @@ public class CharInfo extends L2GameServerPacket
 	private int _mAtkSpd, _pAtkSpd;
 	
 	/**
-     * Run speed, swimming run speed and flying run speed
-     */
+	 * Run speed, swimming run speed and flying run speed
+	 */
 	private int _runSpd;
 	/**
-     * Walking speed, swimming walking speed and flying walking speed
-     */
+	 * Walking speed, swimming walking speed and flying walking speed
+	 */
 	private int _walkSpd;
-    private float _moveMultiplier, _attackSpeedMultiplier;
+	private float _moveMultiplier, _attackSpeedMultiplier;
+	private int _territoryId;
+	private boolean _isDisguised;
 
 	/**
 	 * @param _characters
 	 */
-    public CharInfo(L2PcInstance cha)
-    {
-    	_activeChar = cha;
-    	_inv = cha.getInventory();
-    	_x = _activeChar.getX();
-    	_y = _activeChar.getY();
-    	_z = _activeChar.getZ();
-    	_heading = _activeChar.getHeading();
-    	_mAtkSpd = _activeChar.getMAtkSpd();
-    	_pAtkSpd = _activeChar.getPAtkSpd();
-    	_moveMultiplier  = _activeChar.getMovementSpeedMultiplier();
-    	_attackSpeedMultiplier = _activeChar.getAttackSpeedMultiplier();
-    	_runSpd = (int)(_activeChar.getRunSpeed()/_moveMultiplier);
-    	_walkSpd = (int)(_activeChar.getWalkSpeed()/_moveMultiplier);
-        _invisible = cha.getAppearance().getInvisible();
-    }
+	public CharInfo(L2PcInstance cha)
+	{
+		_activeChar = cha;
+		_inv = cha.getInventory();
+		_x = _activeChar.getX();
+		_y = _activeChar.getY();
+		_z = _activeChar.getZ();
+		_heading = _activeChar.getHeading();
+		_mAtkSpd = _activeChar.getMAtkSpd();
+		_pAtkSpd = _activeChar.getPAtkSpd();
+		_moveMultiplier  = _activeChar.getMovementSpeedMultiplier();
+		_attackSpeedMultiplier = _activeChar.getAttackSpeedMultiplier();
+		_runSpd = (int)(_activeChar.getRunSpeed()/_moveMultiplier);
+		_walkSpd = (int)(_activeChar.getWalkSpeed()/_moveMultiplier);
+		_invisible = cha.getAppearance().getInvisible();
+		_territoryId = TerritoryWarManager.getInstance().getRegisteredTerritoryId(cha);
+		_isDisguised = TerritoryWarManager.getInstance().isDisguised(cha.getObjectId());
+	}
 
 	@Override
 	protected final void writeImpl()
@@ -120,7 +125,7 @@ public class CharInfo extends L2GameServerPacket
 				writeD(_runSpd); // TODO: the order of the speeds should be confirmed
 				writeD(_walkSpd);
 				writeD(_runSpd); // swim run speed
-	            writeD(_walkSpd); // swim walk speed
+				writeD(_walkSpd); // swim walk speed
 				writeD(_runSpd); // fly run speed
 				writeD(_walkSpd); // fly walk speed
 				writeD(_runSpd); // fly run speed ?
@@ -175,18 +180,18 @@ public class CharInfo extends L2GameServerPacket
 				writeD(0);  // C2
 				writeD(0);  // C2
 				writeC(0);  // C2
-                writeC(0x00);  // C3  team circle 1-blue, 2-red
-                writeF(template.fCollisionRadius);
-                writeF(template.fCollisionHeight);
-                writeD(0x00);  // C4
-                writeD(0x00);  // C6
-                writeD(0x00);
-                writeD(0x00);
-    	        writeC(0x01);
-                writeC(0x01);
-                writeD(0x00);
+				writeC(0x00);  // C3  team circle 1-blue, 2-red
+				writeF(template.fCollisionRadius);
+				writeF(template.fCollisionHeight);
+				writeD(0x00);  // C4
+				writeD(0x00);  // C6
+				writeD(0x00);
+				writeD(0x00);
+				writeC(0x01);
+				writeC(0x01);
+				writeD(0x00);
 			}
-            else
+			else
 			{
 				_log.warning("Character "+_activeChar.getName()+" ("+_activeChar.getObjectId()+") morphed in a Npc ("+_activeChar.getPoly().getPolyId()+") w/o template.");
 			}
@@ -271,31 +276,31 @@ public class CharInfo extends L2GameServerPacket
 	
 			writeD(_runSpd); // TODO: the order of the speeds should be confirmed
 			writeD(_walkSpd);
-	        writeD(_runSpd); // swim run speed
-	        writeD(_walkSpd); // swim walk speed
+			writeD(_runSpd); // swim run speed
+			writeD(_walkSpd); // swim walk speed
 			writeD(_runSpd); // fly run speed
 			writeD(_walkSpd); // fly walk speed
 			writeD(_runSpd); // fly run speed ?
 			writeD(_walkSpd); // fly walk speed ?
 			writeF(_activeChar.getMovementSpeedMultiplier()); // _activeChar.getProperMultiplier()
 			writeF(_activeChar.getAttackSpeedMultiplier()); // _activeChar.getAttackSpeedMultiplier()
-            
+			
 			if (_activeChar.getMountType() != 0)
-            {
-            	writeF(NpcTable.getInstance().getTemplate(_activeChar.getMountNpcId()).fCollisionRadius);
-            	writeF(NpcTable.getInstance().getTemplate(_activeChar.getMountNpcId()).fCollisionHeight);
-            }
-            else if (_activeChar.getTransformation() != null)
-            {
-            	writeF(_activeChar.getTransformation().getCollisionRadius());
-            	writeF(_activeChar.getTransformation().getCollisionHeight());
-            }
-            else
-            {
-                writeF(_activeChar.getCollisionRadius());
-                writeF(_activeChar.getCollisionHeight());
-            }
-            
+			{
+				writeF(NpcTable.getInstance().getTemplate(_activeChar.getMountNpcId()).fCollisionRadius);
+				writeF(NpcTable.getInstance().getTemplate(_activeChar.getMountNpcId()).fCollisionHeight);
+			}
+			else if (_activeChar.getTransformation() != null)
+			{
+				writeF(_activeChar.getTransformation().getCollisionRadius());
+				writeF(_activeChar.getTransformation().getCollisionHeight());
+			}
+			else
+			{
+				writeF(_activeChar.getCollisionRadius());
+				writeF(_activeChar.getCollisionHeight());
+			}
+			
 			writeD(_activeChar.getAppearance().getHairStyle());
 			writeD(_activeChar.getAppearance().getHairColor());
 			writeD(_activeChar.getAppearance().getFace());
@@ -323,9 +328,9 @@ public class CharInfo extends L2GameServerPacket
 				writeD(0);
 				writeD(0);
 			}
-	        // In UserInfo leader rights and siege flags, but here found nothing??
-	        // Therefore RelationChanged packet with that info is required
-	        writeD(0);
+			// In UserInfo leader rights and siege flags, but here found nothing??
+			// Therefore RelationChanged packet with that info is required
+			writeD(0);
 
 			writeC(_activeChar.isSitting() ? 0 : 1);	// standing = 1  sitting = 0
 			writeC(_activeChar.isRunning() ? 1 : 0);	// running = 1   walking = 0
@@ -365,14 +370,14 @@ public class CharInfo extends L2GameServerPacket
 
 			writeD(_activeChar.getClassId().getId());
 			writeD(0x00); //?
-	        writeC(_activeChar.isMounted() ? 0 : _activeChar.getEnchantEffect());
+			writeC(_activeChar.isMounted() ? 0 : _activeChar.getEnchantEffect());
 
-	        if(_activeChar.getTeam()==1)
-	        	writeC(0x01); //team circle around feet 1= Blue, 2 = red
-	        else if(_activeChar.getTeam()==2)
-	        	writeC(0x02); //team circle around feet 1= Blue, 2 = red
-	        else
-	        	writeC(0x00); //team circle around feet 1= Blue, 2 = red
+			if(_activeChar.getTeam()==1)
+				writeC(0x01); //team circle around feet 1= Blue, 2 = red
+			else if(_activeChar.getTeam()==2)
+				writeC(0x02); //team circle around feet 1= Blue, 2 = red
+			else
+				writeC(0x00); //team circle around feet 1= Blue, 2 = red
 
 			writeD(_activeChar.getClanCrestLargeId());
 			writeC(_activeChar.isNoble() ? 1 : 0); // Symbol on char menu ctrl+I
@@ -383,37 +388,37 @@ public class CharInfo extends L2GameServerPacket
 			writeD(_activeChar.getFishy());
 			writeD(_activeChar.getFishz());
 
-	        writeD(_activeChar.getAppearance().getNameColor());
-
-	        writeD(_heading);
-
-	        writeD(_activeChar.getPledgeClass());
-	        writeD(_activeChar.getPledgeType());
-
-	        writeD(_activeChar.getAppearance().getTitleColor());
-
-	        if (_activeChar.isCursedWeaponEquipped())
-	        	writeD(CursedWeaponsManager.getInstance().getLevel(_activeChar.getCursedWeaponEquippedId()));
-	        else
-	        	writeD(0x00);
-
-	        if (_activeChar.getClanId() > 0)
-	        	writeD(_activeChar.getClan().getReputationScore());
-	        else
-	        	writeD(0x00); 
-
-	        // T1
-	        writeD(_activeChar.getTransformationId());
-	        writeD(_activeChar.getAgathionId());
-	        
-	        // T2
-	        writeD(0x01);
-	        
-	        // T2.3
-	        writeD(_activeChar.getSpecialEffect());
-	        writeD(0x00);
-	        writeD(0x00);
-	        writeD(0x00);
+			writeD(_activeChar.getAppearance().getNameColor());
+
+			writeD(_heading);
+
+			writeD(_activeChar.getPledgeClass());
+			writeD(_activeChar.getPledgeType());
+
+			writeD(_activeChar.getAppearance().getTitleColor());
+
+			if (_activeChar.isCursedWeaponEquipped())
+				writeD(CursedWeaponsManager.getInstance().getLevel(_activeChar.getCursedWeaponEquippedId()));
+			else
+				writeD(0x00);
+
+			if (_activeChar.getClanId() > 0)
+				writeD(_activeChar.getClan().getReputationScore());
+			else
+				writeD(0x00); 
+
+			// T1
+			writeD(_activeChar.getTransformationId());
+			writeD(_activeChar.getAgathionId());
+			
+			// T2
+			writeD(0x01);
+			
+			// T2.3
+			writeD(_activeChar.getSpecialEffect());
+			writeD(_territoryId); // territory Id
+			writeD((_isDisguised ? 0x01: 0x00)); // is Disguised
+			writeD(_territoryId); // territory Id
 		}
 	}
 

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/Die.java

@@ -17,6 +17,7 @@ package com.l2jserver.gameserver.network.serverpackets;
 import com.l2jserver.gameserver.datatables.AccessLevels;
 import com.l2jserver.gameserver.instancemanager.CastleManager;
 import com.l2jserver.gameserver.instancemanager.FortManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2AccessLevel;
 import com.l2jserver.gameserver.model.L2Clan;
 import com.l2jserver.gameserver.model.L2SiegeClan;
@@ -111,9 +112,9 @@ public class Die extends L2GameServerPacket
             writeD(_clan.getHasHideout() > 0 ? 0x01 : 0x00);            // 6d 01 00 00 00 - to hide away
             writeD(_clan.getHasCastle() > 0  ||
             		isInCastleDefense? 0x01 : 0x00);             		// 6d 02 00 00 00 - to castle
-            writeD(siegeClan != null &&
-            	   !isInCastleDefense && ! isInFortDefense &&
-                   !siegeClan.getFlag().isEmpty() ? 0x01 : 0x00);       // 6d 03 00 00 00 - to siege HQ
+            writeD((TerritoryWarManager.getInstance().getFlagForClan(_clan) != null)
+            		|| (siegeClan != null && !isInCastleDefense && !isInFortDefense
+            		&& !siegeClan.getFlag().isEmpty()) ? 0x01 : 0x00);       // 6d 03 00 00 00 - to siege HQ
             writeD(_sweepable ? 0x01 : 0x00);                               // sweepable  (blue glow)
             writeD(_access.allowFixedRes() ? 0x01: 0x00);                  // 6d 04 00 00 00 - to FIXED
             writeD(_clan.getHasFort() > 0  || isInFortDefense? 0x01 : 0x00);    // 6d 05 00 00 00 - to fortress

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/ExReplyDominionInfo.java

@@ -14,13 +14,11 @@
  */
 package com.l2jserver.gameserver.network.serverpackets;
 
-import java.util.Calendar;
-import java.util.List;
-import java.util.logging.Logger;
+import javolution.util.FastList;
 
-import com.l2jserver.gameserver.datatables.ClanTable;
 import com.l2jserver.gameserver.instancemanager.CastleManager;
-import com.l2jserver.gameserver.model.entity.Castle;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager.Territory;
 
 /**
  *
@@ -31,8 +29,8 @@ public class ExReplyDominionInfo extends L2GameServerPacket
 	/**
 	 * @see com.l2jserver.gameserver.network.serverpackets.L2GameServerPacket#getType()
 	 */
-	private static Logger _log = Logger.getLogger(ExReplyDominionInfo.class.getName());
-	private int _warTime = (int) (Calendar.getInstance().getTimeInMillis() / 1000);
+	// private static Logger _log = Logger.getLogger(ExReplyDominionInfo.class.getName());
+	private int _warTime = (int) (TerritoryWarManager.getInstance().getTWStartTimeInMillis() / 1000);
 
 	/**
 	 * @see com.l2jserver.gameserver.network.serverpackets.L2GameServerPacket#writeImpl()
@@ -42,29 +40,16 @@ public class ExReplyDominionInfo extends L2GameServerPacket
 	{
 		writeC(0xfe);
 		writeH(0x92);
-		List<Castle> castles = CastleManager.getInstance().getCastles();
-		writeD(castles.size());
-		for (Castle castle : castles)
+		FastList<Territory> territoryList = TerritoryWarManager.getInstance().getAllTerritories();
+		writeD(territoryList.size()); // Territory Count
+		for (Territory t : territoryList)
 		{
-			writeD(0x50 + castle.getCastleId()); // territory ID
-			writeS(castle.getName().toLowerCase() + "_dominion"); // territory name
-			if (castle.getOwnerId() > 0)
-			{
-				if (ClanTable.getInstance().getClan(castle.getOwnerId()) != null)
-					writeS(ClanTable.getInstance().getClan(castle.getOwnerId()).getName());
-				else
-				{
-					_log.warning("Castle owner with no name! Castle: " + castle.getName()
-					        + " has an OwnerId = " + castle.getOwnerId()
-					        + " who does not have a  name!");
-					writeS("");
-				}
-			}
-			else
-				writeS("");
-
-			writeD(1); // wards count
-			writeD(0x50 + castle.getCastleId()); // territory ID's
+			writeD(t.getTerritoryId()); // Territory Id
+			writeS(CastleManager.getInstance().getCastleById(t.getCastleId()).getName().toLowerCase() + "_dominion"); // territory name
+			writeS(t.getOwnerClan().getName());
+			writeD(t.getOwnedWardIds().size()); // Emblem Count
+			for(int i:t.getOwnedWardIds())
+				writeD(i); // Emblem ID - should be in for loop for emblem count
 			writeD(_warTime);
 		}
 	}

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/ExShowDominionRegistry.java

@@ -15,12 +15,13 @@
 package com.l2jserver.gameserver.network.serverpackets;
 
 import java.util.Calendar;
-import java.util.List;
 
-import com.l2jserver.gameserver.datatables.ClanTable;
-import com.l2jserver.gameserver.instancemanager.CastleManager;
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager.Territory;
 import com.l2jserver.gameserver.model.L2Clan;
-import com.l2jserver.gameserver.model.entity.Castle;
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 
 /**
  * format: dSSSdddddddd (dd(d))
@@ -28,33 +29,30 @@ import com.l2jserver.gameserver.model.entity.Castle;
  */
 public class ExShowDominionRegistry extends L2GameServerPacket
 {
-	private int _territoryId;
+	private final static int MINID = 80;
+	private final int _castleId;
 	private int _clanReq = 0x00;
 	private int _mercReq = 0x00;
-	private String _clanName = "";
-	private String _clanLeader = "";
-	private String _allyName = "";
+	private int _isMercRegistered = 0x00;
+	private int _isClanRegistered = 0x00;
 	private int _warTime = (int) (Calendar.getInstance().getTimeInMillis() / 1000);
 	private int _currentTime = (int) (Calendar.getInstance().getTimeInMillis() / 1000);
 
-	public ExShowDominionRegistry(int castleId)
+	public ExShowDominionRegistry(int castleId, L2PcInstance player)
 	{
-		_territoryId = 0x50 + castleId;
-		int owner = CastleManager.getInstance().getCastleById(castleId).getOwnerId();
-		if (owner != 0)
+		_castleId = castleId;
+		if (TerritoryWarManager.getInstance().getRegisteredClans(castleId) != null)
+		{
+			_clanReq = TerritoryWarManager.getInstance().getRegisteredClans(castleId).size();
+			if (player.getClan() != null)
+				_isClanRegistered = (TerritoryWarManager.getInstance().getRegisteredClans(castleId).contains(player.getClan()) ? 0x01 : 0x00);
+		}
+		if (TerritoryWarManager.getInstance().getRegisteredMercenaries(castleId) != null)
 		{
-			try
-			{
-				L2Clan clan = ClanTable.getInstance().getClan(owner);
-				_clanName = clan.getName();
-				_clanLeader = clan.getLeaderName();
-				_allyName = clan.getAllyName();
-			}
-			catch (Exception e)
-			{
-				e.printStackTrace();
-			}
+			_mercReq = TerritoryWarManager.getInstance().getRegisteredMercenaries(castleId).size();
+			_isMercRegistered = (TerritoryWarManager.getInstance().getRegisteredMercenaries(castleId).contains(player.getObjectId()) ? 0x01 : 0x00);
 		}
+		_warTime = (int) (TerritoryWarManager.getInstance().getTWStartTimeInMillis() / 1000);
 	}
 
 	/**
@@ -74,25 +72,36 @@ public class ExShowDominionRegistry extends L2GameServerPacket
 	{
 		writeC(0xfe);
 		writeH(0x90);
-		writeD(_territoryId); // Current Territory Id
-		writeS(_clanName); // Owners Clan
-		writeS(_clanLeader); // Owner Clan Leader
-		writeS(_allyName); // Owner Alliance
+		writeD(MINID+_castleId); // Current Territory Id
+		if (TerritoryWarManager.getInstance().getTerritory(_castleId) == null)
+		{
+			// something is wrong
+			writeS("No Owner"); // Owners Clan
+			writeS("No Owner"); // Owner Clan Leader
+			writeS("No Ally"); // Owner Alliance
+		}
+		else
+		{
+			L2Clan clan = TerritoryWarManager.getInstance().getTerritory(_castleId).getOwnerClan();
+			writeS(clan.getName()); // Owners Clan
+			writeS(clan.getLeaderName()); // Owner Clan Leader
+			writeS(clan.getAllyName()); // Owner Alliance
+		}
 		writeD(_clanReq); // Clan Request
 		writeD(_mercReq); // Merc Request
 		writeD(_warTime); // War Time
 		writeD(_currentTime); // Current Time
-		writeD(0x00); // unknown
-		writeD(0x00); // unknown
+		writeD(_isClanRegistered); // is Cancel clan registration
+		writeD(_isMercRegistered); // is Cancel mercenaries registration
 		writeD(0x01); // unknown
-		List<Castle> castles = CastleManager.getInstance().getCastles();
-		writeD(castles.size());
-		for (Castle castle : castles)
+		FastList<Territory> territoryList = TerritoryWarManager.getInstance().getAllTerritories();
+		writeD(territoryList.size()); // Territory Count
+		for (Territory t : territoryList)
 		{
-			writeD(0x50 + castle.getCastleId()); // Territory Id
-			writeD(0x01); // Emblem Count
-			writeD(0x50 + castle.getCastleId()); // Emblem ID - should be in for loop for emblem
-												 // count
+			writeD(t.getTerritoryId()); // Territory Id
+			writeD(t.getOwnedWardIds().size()); // Emblem Count
+			for(int i:t.getOwnedWardIds())
+				writeD(i); // Emblem ID - should be in for loop for emblem count
 		}
 	}
 }

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/ExShowOwnthingPos.java

@@ -0,0 +1,93 @@
+/*
+ * This program 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.
+ * 
+ * This program 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.network.serverpackets;
+
+import javolution.util.FastList;
+
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
+import com.l2jserver.gameserver.model.TerritoryWard;
+
+/**
+ * Format: (ch) d[dddd]
+ *
+ * @author  -Gigiikun-
+ */
+public class ExShowOwnthingPos extends L2GameServerPacket
+{
+	private static final String _S__FE_93_EXSHOWOWNTHINGPOS = "[S] FE:93 ExShowOwnthingPos";
+
+	public ExShowOwnthingPos()
+	{
+	}
+
+	/**
+	 * @see com.l2jserver.gameserver.serverpackets.ServerBasePacket#writeImpl()
+	 */
+	@Override
+	protected void writeImpl()
+	{
+		writeC(0xfe);
+		writeH(0x93);
+
+		if (TerritoryWarManager.getInstance().isTWInProgress())
+		{
+			FastList<TerritoryWard> territoryWardList = TerritoryWarManager.getInstance().getAllTerritoryWards();
+			writeD(territoryWardList.size());
+			for(TerritoryWard ward : territoryWardList)
+			{
+				writeD(ward.getTerritoryId());
+
+				if (ward.getNpc() != null)
+				{
+					writeD(ward.getNpc().getX());
+					writeD(ward.getNpc().getY());
+					writeD(ward.getNpc().getZ());
+				}
+				else if (ward.getPlayer() != null)
+				{
+					writeD(ward.getPlayer().getX());
+					writeD(ward.getPlayer().getY());
+					writeD(ward.getPlayer().getZ());
+				}
+				else if (ward.getItemInstance() != null)
+				{
+					writeD(ward.getItemInstance().getX());
+					writeD(ward.getItemInstance().getY());
+					writeD(ward.getItemInstance().getZ());
+				}
+				else
+				{
+					writeD(0);
+					writeD(0);
+					writeD(0);
+				}
+			}
+		}
+		else
+		{
+			writeD(0);
+			writeD(0);
+		}
+	}
+
+	/**
+	 * @see com.l2jserver.gameserver.BasePacket#getType()
+	 */
+	@Override
+	public String getType()
+	{
+		return _S__FE_93_EXSHOWOWNTHINGPOS;
+	}
+}

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/RelationChanged.java

@@ -37,8 +37,8 @@ public final class RelationChanged extends L2GameServerPacket
 	public static final int RELATION_ATTACKER     = 0x00400; // true when attacker
 	public static final int RELATION_ALLY         = 0x00800; // blue siege icon, cannot have if red
 	public static final int RELATION_ENEMY        = 0x01000; // true when red icon, doesn't matter with blue
-	public static final int RELATION_1SIDED_WAR   = 0x08000; // single fist
 	public static final int RELATION_MUTUAL_WAR   = 0x04000; // double fist
+	public static final int RELATION_1SIDED_WAR   = 0x08000; // single fist
 	public static final int RELATION_ALLY_MEMBER  = 0x10000; // clan is in alliance
 	public static final int RELATION_TERRITORY_WAR= 0x80000; // show Territory War icon
 

L2_GameServer/java/com/l2jserver/gameserver/network/serverpackets/UserInfo.java

@@ -17,6 +17,7 @@ package com.l2jserver.gameserver.network.serverpackets;
 import com.l2jserver.Config;
 import com.l2jserver.gameserver.datatables.NpcTable;
 import com.l2jserver.gameserver.instancemanager.CursedWeaponsManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.Elementals;
 import com.l2jserver.gameserver.model.L2Transformation;
 import com.l2jserver.gameserver.model.actor.L2Summon;
@@ -79,6 +80,8 @@ public final class UserInfo extends L2GameServerPacket
     private int _walkSpd;
     private int _relation;
     private float _moveMultiplier;
+    private int _territoryId;
+    private boolean _isDisguised;
 
     /**
      * @param _characters
@@ -90,9 +93,17 @@ public final class UserInfo extends L2GameServerPacket
         _moveMultiplier = _activeChar.getMovementSpeedMultiplier();
         _runSpd = (int) (_activeChar.getRunSpeed() / _moveMultiplier);
         _walkSpd = (int) (_activeChar.getWalkSpeed() / _moveMultiplier);
+        _territoryId = TerritoryWarManager.getInstance().getRegisteredTerritoryId(character);
         _relation = _activeChar.isClanLeader() ? 0x40 : 0;
-        if (_activeChar.getSiegeState() == 1) _relation |= 0x180;
+        if (_activeChar.getSiegeState() == 1)
+        {
+        	if (_territoryId == 0)
+        		_relation |= 0x180;
+        	else
+        		_relation |= 0x1000;
+        }
         if (_activeChar.getSiegeState() == 2) _relation |= 0x80;
+        _isDisguised = TerritoryWarManager.getInstance().isDisguised(character.getObjectId());
     }
 
     @Override
@@ -358,9 +369,9 @@ public final class UserInfo extends L2GameServerPacket
         writeD(_activeChar.isMinimapAllowed() ? 1: 0); // Minimap on Hellbound
         writeD(_activeChar.getVitalityPoints());  // Vitality Points
         writeD(_activeChar.getSpecialEffect());
-        writeD(0x00); // CT2.3
-        writeD(0x00); // CT2.3
-        writeD(0x00); // CT2.3
+        writeD(_territoryId); // CT2.3
+        writeD((_isDisguised ? 0x01: 0x00)); // CT2.3
+        writeD(_territoryId); // CT2.3
     }
 
     /* (non-Javadoc)

L2_GameServer/java/com/l2jserver/gameserver/skills/DocumentBase.java

@@ -508,6 +508,11 @@ abstract class DocumentBase
                 int value = Integer.decode(getValue(a.getNodeValue(), null));
                 cond = joinAnd(cond, new ConditionSiegeZone(value, true));
             }
+            else if ("siegeside".equalsIgnoreCase(a.getNodeName()))
+            {
+                int value = Integer.decode(getValue(a.getNodeValue(), null));
+                cond = joinAnd(cond, new ConditionPlayerSiegeSide(value));
+            }
             else if ("battle_force".equalsIgnoreCase(a.getNodeName()))
             {
                 forces[0] = Byte.decode(getValue(a.getNodeValue(), null));

L2_GameServer/java/com/l2jserver/gameserver/skills/conditions/ConditionPlayerSiegeSide.java

@@ -0,0 +1,35 @@
+/*
+ * This program 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.
+ * 
+ * This program 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.skills.conditions;
+
+import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
+import com.l2jserver.gameserver.skills.Env;
+
+public class ConditionPlayerSiegeSide extends Condition
+{
+
+	private final int _siegeSide;
+
+	public ConditionPlayerSiegeSide(int side)
+	{
+		_siegeSide = side;
+	}
+
+	@Override
+	public boolean testImpl(Env env)
+	{
+		return ((L2PcInstance)env.player).getSiegeSide() == _siegeSide;
+	}
+}

L2_GameServer/java/com/l2jserver/gameserver/skills/conditions/ConditionSiegeZone.java

@@ -16,6 +16,7 @@ package com.l2jserver.gameserver.skills.conditions;
 
 import com.l2jserver.gameserver.instancemanager.CastleManager;
 import com.l2jserver.gameserver.instancemanager.FortManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.actor.L2Character;
 import com.l2jserver.gameserver.model.actor.instance.L2PcInstance;
 import com.l2jserver.gameserver.model.entity.Castle;
@@ -36,6 +37,8 @@ public final class ConditionSiegeZone extends Condition
     public final static int COND_FORT_ATTACK = 0x0010;
     public final static int COND_FORT_DEFEND = 0x0020;
     public final static int COND_FORT_NEUTRAL = 0x0040;
+    public final static int COND_TW_CHANNEL = 0x0080;
+    public final static int COND_TW_PROGRESS = 0x0100;
     
     private final int _value;
     private final boolean _self;
@@ -56,7 +59,11 @@ public final class ConditionSiegeZone extends Condition
         Castle castle = CastleManager.getInstance().getCastle(target);
         Fort fort = FortManager.getInstance().getFort(target);
 
-        if ((castle == null) && (fort == null))
+        if ((_value & COND_TW_PROGRESS) != 0 && !TerritoryWarManager.getInstance().isTWInProgress())
+        	return false;
+        else if ((_value & COND_TW_CHANNEL) != 0 && !TerritoryWarManager.getInstance().isTWChannelOpen())
+        	return false;
+        else if ((castle == null) && (fort == null))
         {
         	if ((_value & COND_NOT_ZONE) != 0)
         		return true;
@@ -81,16 +88,18 @@ public final class ConditionSiegeZone extends Condition
         	if ((value & COND_NOT_ZONE) != 0)
         		return true;
         }
-        else if (!castle.getSiege().getIsInProgress())
+        else if (!castle.getZone().isActive())
         {
         	if ((value & COND_NOT_ZONE) != 0)
         		return true;
         }
-        else if ((castle.getSiege().getAttackerClan(player.getClan()) != null) && (value & COND_CAST_ATTACK) != 0)
+        else if ((value & COND_CAST_ATTACK) != 0 && player.isRegisteredOnThisSiegeField(castle.getCastleId())
+        		&& player.getSiegeState() == 1)
         	return true;
-        else if ((castle.getSiege().getDefenderClan(player.getClan()) != null) && (value & COND_CAST_DEFEND) != 0)
+        else if ((value & COND_CAST_DEFEND) != 0 && player.isRegisteredOnThisSiegeField(castle.getCastleId())
+        		&& player.getSiegeState() == 2)
         	return true;
-        else if ((castle.getSiege().getAttackerClan(player.getClan()) == null) && (castle.getSiege().getDefenderClan(player.getClan()) == null) && (value & COND_CAST_NEUTRAL) != 0)
+        else if ((value & COND_CAST_NEUTRAL) != 0 && player.getSiegeState() == 0)
         	return true;
         
         return false;
@@ -108,16 +117,18 @@ public final class ConditionSiegeZone extends Condition
         	if ((value & COND_NOT_ZONE) != 0)
         		return true;
         }
-        else if (!fort.getSiege().getIsInProgress())
+        else if (!fort.getZone().isActive())
         {
         	if ((value & COND_NOT_ZONE) != 0)
         		return true;
         }
-        else if ((fort.getSiege().getAttackerClan(player.getClan()) != null) && (value & COND_FORT_ATTACK) != 0)
+        else if ((value & COND_FORT_ATTACK) != 0 && player.isRegisteredOnThisSiegeField(fort.getFortId())
+        		&& player.getSiegeState() == 1)
         	return true;
-        else if ((fort.getOwnerClan() == player.getClan()) && (value & COND_FORT_DEFEND) != 0)
+        else if ((value & COND_FORT_DEFEND) != 0 && player.isRegisteredOnThisSiegeField(fort.getFortId())
+        		&& player.getSiegeState() == 2)
         	return true;
-        else if ((fort.getSiege().getAttackerClan(player.getClan()) == null) && (fort.getOwnerClan() != player.getClan()) && (value & COND_FORT_NEUTRAL) != 0)
+        else if ((value & COND_FORT_NEUTRAL) != 0 && player.getSiegeState() == 0)
         	return true;
         
         return false;

L2_GameServer/java/com/l2jserver/gameserver/skills/l2skills/L2SkillSiegeFlag.java

@@ -20,6 +20,7 @@ import com.l2jserver.gameserver.instancemanager.CastleManager;
 import com.l2jserver.gameserver.instancemanager.FortManager;
 import com.l2jserver.gameserver.instancemanager.FortSiegeManager;
 import com.l2jserver.gameserver.instancemanager.SiegeManager;
+import com.l2jserver.gameserver.instancemanager.TerritoryWarManager;
 import com.l2jserver.gameserver.model.L2Object;
 import com.l2jserver.gameserver.model.L2Skill;
 import com.l2jserver.gameserver.model.actor.L2Character;
@@ -32,13 +33,15 @@ import com.l2jserver.gameserver.templates.StatsSet;
 public class L2SkillSiegeFlag extends L2Skill
 {
 	private final boolean _isAdvanced;
+	private final boolean _isOutpost;
 	
 	public L2SkillSiegeFlag(StatsSet set)
 	{
 		super(set);
-		_isAdvanced = set.getBool("isadvanced", false);
+		_isAdvanced = set.getBool("isAdvanced", false);
+		_isOutpost = set.getBool("isOutpost", false);
 	}
-
+	
 	/**
 	 * @see com.l2jserver.gameserver.model.L2Skill#useSkill(com.l2jserver.gameserver.model.actor.L2Character, com.l2jserver.gameserver.model.L2Object[])
 	 */
@@ -52,31 +55,43 @@ public class L2SkillSiegeFlag extends L2Skill
 		if (player.getClan() == null || player.getClan().getLeaderId() != player.getObjectId())
 			return;
 		
-		Castle castle = CastleManager.getInstance().getCastle(player);
-		Fort fort = FortManager.getInstance().getFort(player);
-		
-		if ((castle == null) && (fort == null))
+		if (!checkIfOkToPlaceFlag(player, true, _isOutpost))
 			return;
-		
-		if (castle != null)
-		{
-			if (!checkIfOkToPlaceFlag(player, castle, true))
-				return;
-		}
-		else
+
+		// Territory War
+		if (TerritoryWarManager.getInstance().isTWInProgress())
 		{
-			if (!checkIfOkToPlaceFlag(player, fort, true))
-				return;
+			try
+			{
+				// Spawn a new flag
+				L2SiegeFlagInstance flag = new L2SiegeFlagInstance(player, IdFactory.getInstance().getNextId(), NpcTable.getInstance().getTemplate((_isOutpost ? 36590 : 35062)), _isAdvanced, _isOutpost);
+				flag.setTitle(player.getClan().getName());
+				flag.setCurrentHpMp(flag.getMaxHp(), flag.getMaxMp());
+				flag.setHeading(player.getHeading());
+				flag.spawnMe(player.getX(), player.getY(), player.getZ() + 50);
+				if (_isOutpost)
+					TerritoryWarManager.getInstance().setHQForClan(player.getClan(), flag);
+				else
+					TerritoryWarManager.getInstance().addClanFlag(player.getClan(), flag);
+			}
+			catch (Exception e)
+			{
+				player.sendMessage("Error placing flag:" + e);
+				_log.warning("Error placing flag:" + e);
+			}
+			return;
 		}
-		
+		// Fortress/Castle siege
 		try
 		{
 			// Spawn a new flag
-			L2SiegeFlagInstance flag = new L2SiegeFlagInstance(player, IdFactory.getInstance().getNextId(), NpcTable.getInstance().getTemplate(35062), _isAdvanced);
+			L2SiegeFlagInstance flag = new L2SiegeFlagInstance(player, IdFactory.getInstance().getNextId(), NpcTable.getInstance().getTemplate(35062), _isAdvanced, false);
 			flag.setTitle(player.getClan().getName());
 			flag.setCurrentHpMp(flag.getMaxHp(), flag.getMaxMp());
 			flag.setHeading(player.getHeading());
 			flag.spawnMe(player.getX(), player.getY(), player.getZ() + 50);
+			Castle castle = CastleManager.getInstance().getCastle(activeChar);
+			Fort fort = FortManager.getInstance().getFort(activeChar);
 			if (castle != null)
 				castle.getSiege().getFlag(player.getClan()).add(flag);
 			else
@@ -86,6 +101,7 @@ public class L2SkillSiegeFlag extends L2Skill
 		catch (Exception e)
 		{
 			player.sendMessage("Error placing flag:" + e);
+			_log.warning("Error placing flag:" + e);
 		}
 	}
 	
@@ -96,8 +112,12 @@ public class L2SkillSiegeFlag extends L2Skill
 	 * @param isCheckOnly if false, it will send a notification to the player telling him
 	 * why it failed
 	 */
-	public static boolean checkIfOkToPlaceFlag(L2Character activeChar, boolean isCheckOnly)
+	public static boolean checkIfOkToPlaceFlag(L2Character activeChar, boolean isCheckOnly, boolean isOutPost)
 	{
+		if (TerritoryWarManager.getInstance().isTWInProgress())
+			return checkIfOkToPlaceHQ(activeChar, isCheckOnly, isOutPost);
+		else if (isOutPost)
+			return false;
 		Castle castle = CastleManager.getInstance().getCastle(activeChar);
 		Fort fort = FortManager.getInstance().getFort(activeChar);
 		
@@ -179,4 +199,41 @@ public class L2SkillSiegeFlag extends L2Skill
 		return false;
 	}
 
+	/**
+	 * Return true if character clan place a flag<BR><BR>
+	 *
+	 * @param activeChar The L2Character of the character placing the flag
+	 * @param isCheckOnly if false, it will send a notification to the player telling him
+	 * why it failed
+	 */
+	public static boolean checkIfOkToPlaceHQ(L2Character activeChar, boolean isCheckOnly, boolean isOutPost)
+	{
+		Castle castle = CastleManager.getInstance().getCastle(activeChar);
+		Fort fort = FortManager.getInstance().getFort(activeChar);
+		
+		if ((castle == null) && (fort == null))
+			return false;
+		
+		String text = "";
+		L2PcInstance player = (L2PcInstance) activeChar;
+		
+		if ((fort != null && fort.getFortId() == 0) || (castle != null && castle.getCastleId() == 0))
+			text = "You must be on fort or castle ground to construct an outpost or flag.";
+		else if ((fort != null && !fort.getZone().isActive()) || (castle != null && !castle.getZone().isActive()))
+			text = "You can only construct an outpost or flag on siege field.";
+		else if (player.getClan() == null || !player.isClanLeader())
+			text = "You must be a clan leader to construct an outpost or flag.";
+		else if (TerritoryWarManager.getInstance().getHQForClan(player.getClan()) != null && isOutPost)
+			text = "You can have only one outpost.";
+		else if (TerritoryWarManager.getInstance().getFlagForClan(player.getClan()) != null && !isOutPost)
+			text = "You can have only one flag.";
+		else if (player.isInsideZone(L2Character.ZONE_NOHQ))
+			text = "You cannot construct outpost or flag here.";
+		else
+			return true;
+		
+		if (!isCheckOnly)
+			player.sendMessage(text);
+		return false;
+	}
 }

L2_GameServer/java/com/l2jserver/gameserver/skills/l2skills/L2SkillTeleport.java

@@ -71,6 +71,12 @@ public class L2SkillTeleport extends L2Skill
 				return;
 			}
 
+			if (((L2PcInstance)activeChar).isCombatFlagEquipped())
+			{
+				activeChar.sendPacket(ActionFailed.STATIC_PACKET);
+				return;
+			}
+
 			if (((L2PcInstance) activeChar).isInOlympiadMode())
 			{
 				activeChar.sendPacket(new SystemMessage(SystemMessageId.THIS_ITEM_IS_NOT_AVAILABLE_FOR_THE_OLYMPIAD_EVENT));
@@ -123,6 +129,9 @@ public class L2SkillTeleport extends L2Skill
 
 						if (GrandBossManager.getInstance().getZone(targetChar) != null)
 							continue;
+
+						if (targetChar.isCombatFlagEquipped())
+							continue;
 					}
 				}
 				Location loc = null;

L2_GameServer/java/config/Character.properties

@@ -351,7 +351,7 @@ AugmentationTopGlowChance = 100
 # Shadow, common, time-limited, hero, pvp, wear items are hardcoded, as well as all etcitems.
 # Rods can't be augmented too.
 # Default: 6656,6657,6658,6659,6660,6661,6662,8191,10170,10314
-AugmentationBlackList = 6656,6657,6658,6659,6660,6661,6662,8191,10170,10314
+AugmentationBlackList = 6656,6657,6658,6659,6660,6661,6662,8191,10170,10314,13740,13741,13742,13743,13744,13745,13746,13747,13748,14592,14593,14594,14595,14596,14597,14598,14599,14600,14664,14665,14666,14667,14668,14669,14670,14671,14672,14801,14802,14803,14804,14805,14806,14807,14808,14809,15282,15283,15284,15285,15286,15287,15288,15289,15290,15291,15292,15293,15294,15295,15296,15297,15298,15299
 
 # ---------------------------------------------------------------------------
 # Karma

L2_GameServer/java/config/territorywar.properties

@@ -0,0 +1,44 @@
+# ---------------------------------------------------------------------------
+# TerritoryWar Settings
+# ---------------------------------------------------------------------------
+# The defaults are set to be retail-like. If you modify any of these settings your server will deviate from being retail-like.
+# Warning: 
+# Please take extreme caution when changing anything. Also please understand what you are changing before you do so on a live server.
+# ---------------------------------------------------------------------------
+# Standard Settings
+# ---------------------------------------------------------------------------
+
+# Length of siege before the count down (in minutes).
+# Default: 120
+WarLength = 120
+
+# Clan Minimum level to register.
+# Default: 0
+ClanMinLevel = 0
+
+# Player Minimum level to register.
+# Default: 40
+PlayerMinLevel = 40
+
+# Max number of clans and players that can register for a side.
+# Default: 500
+DefenderMaxClans = 500
+
+# Default: 500
+DefenderMaxPlayers = 500
+
+# Is Ward holding players can be attacked and killed in peace zone
+# Default: False
+PlayerWithWardCanBeKilledInPeaceZone = False
+
+# Territory Badge needed to change nobless
+# default: 100
+MinTerritoryBadgeForNobless = 100
+
+# Territory Badge needed to buy Strider
+# default: 50
+MinTerritoryBadgeForStriders = 50
+
+# Territory Badge needed to buy Guardian's Strider
+# default: 80
+MinTerritoryBadgeForBigStrider = 80