/// <summary>
		/// Sends a message to all players to notify them of the keep capture
		/// </summary>
		/// <param name="keep">The keep object</param>
		public static void BroadcastCapture(AbstractGameKeep keep)
		{
			string message = "";
			if (keep.Realm != eRealm.None)
			{
				message = string.Format(LanguageMgr.GetTranslation(ServerProperties.Properties.SERV_LANGUAGE, "PlayerManager.BroadcastCapture.Captured", GlobalConstants.RealmToName((eRealm)keep.Realm), keep.Name));
			}
			else
			{
                message = string.Format(LanguageMgr.GetTranslation(ServerProperties.Properties.SERV_LANGUAGE, "PlayerManager.BroadcastCapture.CapturedR0", GlobalConstants.RealmToName((eRealm)keep.Realm), keep.Name));
			}

			/*
			switch (GameServer.Instance.Configuration.ServerType)
			{
				case eGameServerType.GST_Normal:
					{
						message = string.Format("The forces of {0} have captured {1}!", GlobalConstants.RealmToName((eRealm)keep.Realm), keep.Name);
						break;
					}
				case eGameServerType.GST_PvP:
					{
						string defeatersStr = "";
						message = string.Format("The forces of {0} have defeated the defenders of {1}!", defeatersStr, keep.Name);
						break;
					}
			}*/

			BroadcastMessage(message, eRealm.None);
			NewsMgr.CreateNews(message, keep.Realm, eNewsType.RvRGlobal, false);
		}

		public static void SendLevelChangeMessage(AbstractGameKeep keep)
		{
			string message = "Your guild's keep " + keep.Name + " is now level " + keep.Level;
			if (keep.Level != ServerProperties.Properties.MAX_KEEP_LEVEL)
				message += ", it is on the way to level " + ServerProperties.Properties.MAX_KEEP_LEVEL.ToString();
			SendMessageToGuild(message, keep.Guild);
		}

		public override void SendKeepRemove(AbstractGameKeep keep)
		{
			GSTCPPacketOut pak = new GSTCPPacketOut(GetPacketCode(eServerPackets.KeepRemove));

			pak.WriteShort((ushort)keep.KeepID);
			SendTCP(pak);
		}

        public ScoutMission(object owner)
            : base(owner)
        {
            eRealm realm = 0;
            if (owner is Group)
                realm = (owner as Group).Leader.Realm;
            else if (owner is GamePlayer)
                realm = (owner as GamePlayer).Realm;

            ArrayList list = new ArrayList();

            ICollection<AbstractGameKeep> keeps;
            if (owner is Group)
                keeps = GameServer.KeepManager.GetKeepsOfRegion((owner as Group).Leader.CurrentRegionID);
            else if (owner is GamePlayer)
                keeps = GameServer.KeepManager.GetKeepsOfRegion((owner as GamePlayer).CurrentRegionID);
            else keeps = new List<AbstractGameKeep>();

            foreach (AbstractGameKeep keep in keeps)
            {
                if (keep.IsPortalKeep)
                    continue;
                if (keep.Realm != realm)
                    list.Add(keep);
            }

            if (list.Count > 0)
                m_keep = list[Util.Random(list.Count - 1)] as AbstractGameKeep;

            GameEventMgr.AddHandler(AreaEvent.PlayerEnter, new DOLEventHandler(Notify));
            GameEventMgr.AddHandler(KeepEvent.KeepTaken, new DOLEventHandler(Notify));
        }

		public static void SendChangeLevelTimeMessage(AbstractGameKeep keep)
		{
            string message;
            string changeleveltext = "";
            int nextlevel = 0;

            byte maxlevel = (byte)ServerProperties.Properties.MAX_KEEP_LEVEL;

            if (keep.Level < maxlevel)
            {
                changeleveltext = "upgrade";
                nextlevel = keep.Level + 1;
            }
            else if (keep.Level > maxlevel)
            {
                changeleveltext = "downgrade";
                nextlevel = keep.Level - 1;
            }
            else
            {
                return;
            }
			message = "Your guild is starting to " + changeleveltext + " its area " + keep.Name + " to level 10.";
			TimeSpan time = keep.ChangeLevelTimeRemaining;
			message += " It will take ";
			if (time.Hours > 0)
				message += time.Hours + " hour(s) ";
			if (time.Minutes > 0)
				message += time.Minutes + " minute(s) ";
			else message += time.Seconds + " second(s)";
			message += " to reach the next level.";
			SendMessageToGuild(message, keep.Guild);
		}

		public override void SendKeepRealmUpdate(AbstractGameKeep keep)
		{
			GSTCPPacketOut pak = new GSTCPPacketOut(GetPacketCode(eServerPackets.KeepRealmUpdate));

			pak.WriteShort((ushort)keep.KeepID);
			pak.WriteByte((byte)keep.Realm);
			pak.WriteByte((byte)keep.Level);
			SendTCP(pak);
		}

		public override void SendKeepInfo(AbstractGameKeep keep)
		{
			GSTCPPacketOut pak = new GSTCPPacketOut(GetPacketCode(eServerPackets.KeepInfo));

			pak.WriteShort((ushort)keep.KeepID);
			pak.WriteShort(0);//zone id not sure
			pak.WriteInt((uint)keep.X);
			pak.WriteInt((uint)keep.Y);
			pak.WriteShort((ushort)keep.Heading);
			pak.WriteByte((byte)keep.Realm);
			pak.WriteByte((byte)keep.Level);//level(not sure)
			pak.WriteShort(0);//unk
			pak.WriteByte(0x57);//model= 5-8Bit =lvl 1-4bit = Keep Type //uncertain
			pak.WriteByte(0xB7);//unk
			SendTCP(pak);
		}

		/// <summary>
		/// load component from db object
		/// </summary>
		public virtual void LoadFromDatabase(DBKeepComponent component, AbstractGameKeep keep)
		{
			Region myregion = WorldMgr.GetRegion((ushort)keep.Region);
			if (myregion == null)
				return;
			this.Keep = keep;
			//this.DBKeepComponent = component;
			base.LoadFromDatabase(component);
			//this x and y is for get object in radius
			double angle = keep.Heading * ((Math.PI * 2) / 360); // angle*2pi/360;
			X = (int)(keep.X + ((sbyte)component.X * 148 * Math.Cos(angle) + (sbyte)component.Y * 148 * Math.Sin(angle)));
			Y = (int)(keep.Y - ((sbyte)component.Y * 148 * Math.Cos(angle) - (sbyte)component.X * 148 * Math.Sin(angle)));
			this.Z = keep.Z;
			// and this one for packet sent
			this.ComponentX = component.X;
			this.ComponentY = component.Y;
			this.ComponentHeading = (ushort)component.Heading;
			//need check to be sure for heading
			angle = (component.Heading * 90 + keep.Heading);
			if (angle > 360) angle -= 360;
			this.Heading = (ushort)(angle / 0.08789);
			this.Name = keep.Name;
			this.Model = INVISIBLE_MODEL;
			this.Skin = component.Skin;
			m_oldMaxHealth = MaxHealth;
			this.Health = MaxHealth;
			//			this.Health = component.Health;
			this.m_oldHealthPercent = this.HealthPercent;
			this.CurrentRegion = myregion;
			this.ID = component.ID;
			this.SaveInDB = false;
			this.IsRaized = false;
			LoadPositions();
			this.AddToWorld();
			FillPositions();
			this.RepairedHealth = this.MaxHealth;
			m_CreateInfo = component.CreateInfo;
			StartHealthRegeneration();
		}

 public virtual void RegisterKeep(int keepID, AbstractGameKeep keep)
 {
     m_keepList.Add(keepID, keep);
     log.Info("Registered Keep: " + keep.Name);
 }

		public KeepEventArgs(AbstractGameKeep keep, eRealm realm)
		{
			this.m_keep = keep;
			this.m_realm = realm;
		}

        /// <summary>
        /// Realm points a keep is worth when captured
        /// </summary>
        /// <param name="keep"></param>
        /// <returns></returns>
        public virtual int GetRealmPointsForKeep(AbstractGameKeep keep)
        {
            int value = 0;

            if (keep is GameKeep)
            {
                value = Math.Max(50, ServerProperties.Properties.KEEP_RP_BASE + ((keep.BaseLevel - 50) * ServerProperties.Properties.KEEP_RP_MULTIPLIER));
            }
            else
            {
                value = Math.Max(5, ServerProperties.Properties.TOWER_RP_BASE + ((keep.BaseLevel - 50) * ServerProperties.Properties.TOWER_RP_MULTIPLIER));
            }

            value += ((keep.Level - ServerProperties.Properties.STARTING_KEEP_LEVEL) * ServerProperties.Properties.UPGRADE_MULTIPLIER);

            return Math.Max(5, value);
        }

		/// <summary>
		/// Sends a message to all players to notify them of the raize
		/// </summary>
		/// <param name="keep">The keep object</param>
		/// <param name="realm">The raizing realm</param>
		public static void BroadcastRaize(AbstractGameKeep keep, eRealm realm)
		{
			string message = string.Format(LanguageMgr.GetTranslation(ServerProperties.Properties.SERV_LANGUAGE, "PlayerManager.BroadcastRaize.Razed", keep.Name, GlobalConstants.RealmToName(realm)));
			BroadcastMessage(message, eRealm.None);
			NewsMgr.CreateNews(message, keep.Realm, eNewsType.RvRGlobal, false);
		}

		public virtual void SendKeepRealmUpdate(AbstractGameKeep keep)
		{
		}

 public int CalcCY(GamePlayer player, AbstractGameKeep myKeep, double angle)
 {
     if (Math.Abs(Math.Sin(angle)) < 0.0001)
     {
         return (myKeep.Y - player.Y) / 148;
     }
     else
     {
         int cx = (int)((148 * Math.Sin(angle) * myKeep.X - 148 * Math.Sin(angle) * player.X + player.Y - myKeep.Y)
                     / (148 * Math.Sin(angle) - 148 * 148 * 2 * Math.Sin(angle) * Math.Cos(angle)));
         return (int)((myKeep.Y - player.Y + 148 * Math.Sin(angle) * cx) / (148 * Math.Cos(angle)));
     }
 }

		/// <summary>
		/// Method to tell us if a player can interact with the lord to do certain tasks
		/// </summary>
		/// <param name="player">The player object</param>
		/// <param name="keep">The area object</param>
		/// <param name="type">The type of interaction</param>
		/// <returns></returns>
		public static bool IsAllowedToInteract(GamePlayer player, AbstractGameKeep keep, eInteractType type)
		{
			if (player.Client.Account.PrivLevel > 1)
				return true;
			if (player.Realm != keep.Realm)
				return false;
			if (player.Guild == null)
				return false;

			if (keep.InCombat)
			{
				log.DebugFormat("KEEPWARNING: {0} attempted to {1} {2} while in combat.", player.Name, type, keep.Name);
				return false;
			}

			switch (type)
			{
				case eInteractType.Claim:
					{
						if (keep.Guild != null)
							return false;
						foreach (AbstractGameKeep k in GameServer.KeepManager.GetAllKeeps())
						{
							if (k.Guild == player.Guild)
								return false;
						}
						if (player.Group == null)
							return false;
						if (player.Group.Leader != player)
							return false;
						if (player.Group.MemberCount < ServerProperties.Properties.CLAIM_NUM)
							return false;
						if (!player.GuildRank.Claim)
							return false;
						break;
					}
				case eInteractType.Release:
					{
						if (keep.Guild == null)
							return false;
						if (keep.Guild != player.Guild)
							return false;
						if (!player.GuildRank.Claim)
							return false;
						break;
					}
				case eInteractType.ChangeLevel:
					{
						if (keep.Guild == null)
							return false;
						if (keep.Guild != player.Guild)
							return false;
						if (!player.GuildRank.Claim)
							return false;
						break;
					}
			}
			return true;
		}

		public virtual void SendKeepComponentUpdate(AbstractGameKeep keep, bool LevelUp)
		{
		}

 public int CalcCX(GamePlayer player, AbstractGameKeep myKeep, double angle)
 {
     if (Math.Abs(Math.Sin(angle)) < 0.0001) //for approximations, == 0 wont work.
     {
         return (player.X - myKeep.X) / 148;
     }
     else
     {
         return (int)((148 * Math.Sin(angle) * myKeep.X - 148 * Math.Sin(angle) * player.X + player.Y - myKeep.Y)
                     / (148 * Math.Sin(angle) - 148 * 148 * 2 * Math.Sin(angle) * Math.Cos(angle)));
     }
 }

		/// <summary>
		/// Creates a guard patrol position
		/// </summary>
		/// <param name="guardID">The guard ID</param>
		/// <param name="component">The component object</param>
		/// <param name="player">The player object</param>
		/// <returns>The position object</returns>
		public static DBKeepPosition CreatePatrolPosition(string guardID, GameKeepComponent component, GamePlayer player, AbstractGameKeep.eKeepType keepType)
		{
			DBKeepPosition pos = CreatePosition(guardID, component, player);
			pos.Height = 0;
			pos.ClassType = "DOL.GS.Keeps.Patrol";
			pos.KeepType = (int)keepType;
			GameServer.Database.AddObject(pos);
			return pos;
		}

		public KeepArea(AbstractGameKeep keep)
			: base(keep.Name, keep.X, keep.Y, 0, keep.IsPortalKeep ? PK_RADIUS : (keep is GameKeepTower ? TOWER_RADIUS : KEEP_RADIUS)
)		{
			Keep = keep;
		}

		private string KeepStringBuilder(AbstractGameKeep keep)
		{
			string buffer = "";
			buffer += keep.Name + ": " + GlobalConstants.RealmToName(keep.Realm);
			if (keep.Guild != null)
			{
				buffer += " (" + keep.Guild.Name + ")";
			}
			buffer += "\n";
			return buffer;
		}