public void LoadFromPosition(DBKeepPosition pos, GameKeepComponent component)
		{
			if (component.Keep.DBKeep.BaseLevel < 50)
				return;
			m_component = component;
			PositionMgr.LoadKeepItemPosition(pos, this);
			this.m_component.Keep.TeleportStone = this;
			this.AddToWorld();
		}
示例#2
0
		public static void LoadGuardPosition(DBKeepPosition pos, GameKeepGuard guard)
		{
			LoadKeepItemPosition(pos, guard);

            guard.SpawnPoint.X = guard.X;
            guard.SpawnPoint.Y = guard.Y;
            guard.SpawnPoint.Z = guard.Z;
			guard.SpawnHeading = guard.Heading;
		}
示例#3
0
		public static void LoadKeepItemPosition(DBKeepPosition pos, IKeepItem item)
		{
			item.CurrentRegionID = item.Component.CurrentRegionID;
			int x, y;
			LoadXY(item.Component, pos.XOff, pos.YOff, out x, out y);
			item.X = x;
			item.Y = y;

			item.Z = item.Component.AbstractKeep.Z + pos.ZOff;

			item.Heading = (ushort)(item.Component.Heading + pos.HOff);

			item.Position = pos;
		}
示例#4
0
		/// <summary>
		/// Move a guard to a position
		/// </summary>
		/// <param name="position">The new position for the guard</param>
		public void MoveToPosition(DBKeepPosition position)
		{
			PositionMgr.LoadGuardPosition(position, this);
			if (!this.InCombat)
				this.MoveTo(this.CurrentRegionID, this.X, this.Y, this.Z, this.Heading);
		}
示例#5
0
		/// <summary>
		/// Load the guard from a position
		/// </summary>
		/// <param name="pos">The position for the guard</param>
		/// <param name="component">The component it is being spawned on</param>
		public void LoadFromPosition(DBKeepPosition pos, GameKeepComponent component)
		{
			m_templateID = pos.TemplateID;
			m_component = component;
			component.AbstractKeep.Guards[m_templateID] = this;
			PositionMgr.LoadGuardPosition(pos, this);
			if (Component != null && Component.AbstractKeep != null)
			{
				Component.AbstractKeep.TemplateManager.GetMethod("RefreshTemplate").Invoke(null, new object[] { this });
			}
			else
			{
				TemplateMgr.RefreshTemplate(this);
			}
			this.AddToWorld();
		}
示例#6
0
		public virtual void LoadPositions()
		{
			ushort region = CurrentRegionID;
			if (CurrentRegion is BaseInstance)
			{
				region = (CurrentRegion as BaseInstance).Skin;
			}

            Battleground bg = KeepMgr.GetBattleground(region);

			this.Positions.Clear();

			string query = "`ComponentSkin` = '" + this.Skin + "'";
			if (Skin != (int)eComponentSkin.Keep && Skin != (int)eComponentSkin.Tower && Skin != (int)eComponentSkin.Gate)
			{
				query = query + " AND `ComponentRotation` = '" + this.ComponentHeading + "'";
			}
			if (bg != null)
			{
				// Battlegrounds, ignore all but GameKeepDoor
				query = query + " AND `ClassType` = 'DOL.GS.Keeps.GameKeepDoor'"; 
			}

			var DBPositions = GameServer.Database.SelectObjects<DBKeepPosition>(query);

			foreach (DBKeepPosition position in DBPositions)
			{
				DBKeepPosition[] list = this.Positions[position.TemplateID] as DBKeepPosition[];
				if (list == null)
				{
					list = new DBKeepPosition[4];
					this.Positions[position.TemplateID] = list;
				}

				list[position.Height] = position;
			}
		}
示例#7
0
        public virtual void LoadFromPosition(DBKeepPosition pos, GameKeepComponent component)
        {
            m_templateID = pos.TemplateID;
            m_component = component;

            PositionMgr.LoadKeepItemPosition(pos, this);
            component.Keep.Doors[m_templateID] = this;

            m_oldMaxHealth = MaxHealth;
            m_health = MaxHealth;
            m_name = "Keep Door";
            m_oldHealthPercent = HealthPercent;
            m_doorID = GenerateDoorID();
            this.m_model = 0xFFFF;
            m_state = eDoorState.Closed;
            this.AddToWorld();
            StartHealthRegeneration();
            DoorMgr.RegisterDoor(this);
        }
示例#8
0
        public void DeleteObject()
        {
            RemoveTimers();

            if (Component != null)
            {
                if (Component.Keep != null)
                {
                    Component.Keep.Doors.Remove(this.ObjectID);
                }

                Component.Delete();
            }

            Component = null;
            Position = null;
            base.Delete();
            CurrentRegion = null;
        }
示例#9
0
文件: keepguard.cs 项目: mynew4/DAoC
		/// <summary>
		/// The command handler itself
		/// </summary>
		/// <param name="client">The client using the command</param>
		/// <param name="args">The command arguments</param>
		public void OnCommand(GameClient client, string[] args)
		{
			if (args.Length == 1)
			{
				DisplaySyntax(client);
				return;
			}

			switch (args[1].ToLower())
			{
				#region Create
				case "create":
					{
						GameKeepGuard guard = null;
						if (args.Length < 3)
						{
							DisplaySyntax(client);
							return;
						}
						
						switch (args[2].ToLower())
						{
							#region Lord
							case "lord":
								{
									guard = new GuardLord();
									break;
								}
							#endregion Lord
							#region Fighter
							case "fighter":
								{
									guard = new GuardFighter();
									break;
								}
							#endregion Fighter
							#region Archer
							case "archer":
								{
									if (args.Length > 3)
										guard = new GuardStaticArcher();
									else
										guard = new GuardArcher();
									break;
								}
							#endregion Archer
							#region Healer
							case "healer":
								{
									guard = new GuardHealer();
									break;
								}
							#endregion Healer
							#region Stealther
							case "stealther":
								{
									guard = new GuardStealther();
									break;
								}
							#endregion Stealther
							#region Caster
							case "caster":
								{
									if (args.Length > 3)
										guard = new GuardStaticCaster();
									else
										guard = new GuardCaster();
									break;
								}
							#endregion Caster
							#region Hastener
							case "hastener":
								{
									guard = new FrontierHastener();
									break;
								}
							#endregion Hastener
							#region Mission
							case "mission":
								{
									guard = new MissionMaster();
									break;
								}
							#endregion Mission
							#region Patrol
							case "patrol":
								{
									if (args.Length < 4)
									{
										DisplayMessage(client, "You need to provide a name for this patrol.");
										return;
									}

									AbstractGameKeep.eKeepType keepType = AbstractGameKeep.eKeepType.Any;

									if (args.Length < 5)
									{
										DisplayMessage(client, "You need to provide the type of keep this patrol works with.");
										int i = 0;
										foreach (string str in Enum.GetNames(typeof(Keeps.AbstractGameKeep.eKeepType)))
										{
											DisplayMessage(client, "#" + i + ": " + str);
											i++;
										}
										return;
									}

									try
									{
										keepType = (AbstractGameKeep.eKeepType)Convert.ToInt32(args[4]);
									}
									catch
									{
										DisplayMessage(client, "Type of keep specified was not valid.");
										return;
									}


									if (client.Player.TargetObject is GameKeepComponent == false)
									{
										DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Create.NoKCompTarget"));
										return;
									}
									GameKeepComponent c = client.Player.TargetObject as GameKeepComponent;;
									Patrol p = new Patrol(c);
									p.PatrolID = args[3];
									p.KeepType = keepType;
									p.SpawnPosition = PositionMgr.CreatePatrolPosition(p.PatrolID, c, client.Player, keepType);
									p.PatrolID = p.SpawnPosition.TemplateID;
									p.InitialiseGuards();
									DisplayMessage(client, "Patrol created for Keep Type " + Enum.GetName(typeof(AbstractGameKeep.eKeepType), keepType));
									return;
								}
							#endregion Patrol
						}

						if (guard == null)
						{
							DisplaySyntax(client);
							return;
						}

						GameKeepComponent component = client.Player.TargetObject as GameKeepComponent;
						if (component != null)
						{
							int height = component.Height;
							if (args.Length > 4)
								int.TryParse(args[4], out height);

							DBKeepPosition pos = PositionMgr.CreatePosition(guard.GetType(), height, client.Player, Guid.NewGuid().ToString(), component);
							//PositionMgr.AddPosition(pos);
							//PositionMgr.FillPositions();
							DBKeepPosition[] list = component.Positions[pos.TemplateID] as DBKeepPosition[];
							if (list == null)
							{
								list = new DBKeepPosition[4];
								component.Positions[pos.TemplateID] = list;
							}
								
							list[pos.Height] = pos;
							component.LoadPositions();
							component.FillPositions();
						}
						else
						{
							guard.CurrentRegion = client.Player.CurrentRegion;
							guard.X = client.Player.X;
							guard.Y = client.Player.Y;
							guard.Z = client.Player.Z;
							guard.Heading = client.Player.Heading;
							guard.Realm = guard.CurrentZone.Realm;
                            guard.LoadedFromScript = false;
                            guard.SaveIntoDatabase();
							
							foreach (AbstractArea area in guard.CurrentAreas)
							{
								if (area is KeepArea)
								{
									AbstractGameKeep keep = (area as KeepArea).Keep;
									guard.Component = new GameKeepComponent();
									guard.Component.Keep = keep;
									break;
								}
							}

							TemplateMgr.RefreshTemplate(guard);
							guard.AddToWorld();

							if (guard.Component != null && guard.Component.Keep != null)
								guard.Component.Keep.Guards.Add(DOL.Database.UniqueID.IDGenerator.GenerateID(), guard);
						}

						PositionMgr.FillPositions();

						DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Create.GuardAdded"));
						break;
					}
				#endregion Create
				#region Position
				case "position":
					{
						switch (args[2].ToLower())
						{
							#region Add
							case "add":
								{
									if (!(client.Player.TargetObject is GameKeepGuard))
									{
										DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Position.TargetGuard"));
										return;
									}

									if (args.Length != 4)
									{
										DisplaySyntax(client);
										return;
									}

									byte height = byte.Parse(args[3]);
									//height = KeepMgr.GetHeightFromLevel(height);
									GameKeepGuard guard = client.Player.TargetObject as GameKeepGuard;
									
									if (PositionMgr.GetPosition(guard) != null)
									{
										DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Position.PAlreadyAss", height));
										return;
									}

									DBKeepPosition pos = PositionMgr.CreatePosition(guard.GetType(), height, client.Player, guard.TemplateID, guard.Component);
									PositionMgr.AddPosition(pos);
									PositionMgr.FillPositions();

									DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Position.GuardPAdded"));
									break;
								}
							#endregion Add
							#region Remove
							case "remove":
								{
									if (!(client.Player.TargetObject is GameKeepGuard))
									{
										DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Position.TargetGuard"));
										return;
									}

									GameKeepGuard guard = client.Player.TargetObject as GameKeepGuard;
									DBKeepPosition pos = guard.Position;
									if (pos != null)
									{
										PositionMgr.RemovePosition(pos);

										if (guard.LoadedFromScript)
										{
											if (guard.PatrolGroup != null)
											{
												foreach (GameKeepGuard g in guard.PatrolGroup.PatrolGuards)
												{
													g.Delete();
												}
											}
											else
											{
												guard.Delete();
											}
										}
									}

									PositionMgr.FillPositions();

									DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Position.GuardRemoved"));
									break;
								}
							#endregion Remove
							#region Default
							default:
								{
									DisplaySyntax(client);
									return;
								}
							#endregion Default
						}
						break;
					}
				#endregion Position
				#region Path
				case "path":
					{
						switch (args[2].ToLower())
						{
							#region Create
							case "create":
								{
									RemoveAllTempPathObjects(client);

									PathPoint startpoint = new PathPoint(client.Player.X, client.Player.Y, client.Player.Z, 100000, ePathType.Once);
									client.Player.TempProperties.setProperty(TEMP_PATH_FIRST, startpoint);
									client.Player.TempProperties.setProperty(TEMP_PATH_LAST, startpoint);
									client.Player.Out.SendMessage(LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Path.CreationStarted"), eChatType.CT_System, eChatLoc.CL_SystemWindow);
									CreateTempPathObject(client, startpoint, "TMP PP 1");
									break;
								}
							#endregion Create
							#region Add
							case "add":
								{
									PathPoint path = (PathPoint)client.Player.TempProperties.getProperty<object>(TEMP_PATH_LAST, null);
									if (path == null)
									{
										DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Path.NoPathCreatedYet"));
										return;
									}

									int speedlimit = 1000;
									if (args.Length == 4)
									{
										try
										{
											speedlimit = int.Parse(args[3]);
										}
										catch
										{
											DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Path.NoValidSpLimit", args[2]));
											return;
										}
									}

									PathPoint newpp = new PathPoint(client.Player.X, client.Player.Y, client.Player.Z, speedlimit, path.Type);
									path.Next = newpp;
									newpp.Prev = path;
									client.Player.TempProperties.setProperty(TEMP_PATH_LAST, newpp);

									int len = 0;
									while (path.Prev != null)
									{
										len++;
										path = path.Prev;
									}
									len += 2;

									CreateTempPathObject(client, newpp, "TMP PP " + len);
									DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Path.PPAdded", len));
									break;
								}
							#endregion Add
							#region Save
							case "save":
								{
									PathPoint path = (PathPoint)client.Player.TempProperties.getProperty<object>(TEMP_PATH_LAST, null);
									if (path == null)
									{
										DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Path.NoPathCreatedYet"));
										return;
									}

									GameKeepGuard guard = client.Player.TargetObject as GameKeepGuard;
									if (guard == null || guard.PatrolGroup == null)
									{
										DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Path.TargPatrolGuard"));
										return;
									}

									path.Type = ePathType.Loop;
									PositionMgr.SavePatrolPath(guard.TemplateID, path, guard.Component);
									DisplayMessage(client, LanguageMgr.GetTranslation(client.Account.Language, "GMCommands.KeepGuard.Path.Saved"));
									RemoveAllTempPathObjects(client);
									guard.PatrolGroup.InitialiseGuards();

									PositionMgr.FillPositions();

									DisplayMessage(client, "Patrol groups initialized!");

									break;
								}
							#endregion Save
							#region Default
							default:
								{
									DisplaySyntax(client);
									return;
								}
							#endregion Default
						}
						break;
					}
				#endregion Path
				#region Default
				default:
					{
						DisplaySyntax(client);
						return;
					}
				#endregion Default
			}
		}
示例#10
0
		public static void CreateDoor(int doorID, GamePlayer player)
		{
			int ownerKeepId = (doorID / 100000) % 1000;
			int towerNum = (doorID / 10000) % 10;
			int keepID = ownerKeepId + towerNum * 256;
			int componentID = (doorID / 100) % 100;
			int doorIndex = doorID % 10;

			AbstractGameKeep keep = GameServer.KeepManager.GetKeepByID(keepID);
			if (keep == null)
			{
				player.Out.SendMessage("Cannot create door as keep is null!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
				return;
			}
			GameKeepComponent component = null;
			foreach (GameKeepComponent c in keep.KeepComponents)
			{
				if (c.ID == componentID)
				{
					component = c;
					break;
				}
			}
			if (component == null)
			{
				player.Out.SendMessage("Cannot create door as component is null!", eChatType.CT_System, eChatLoc.CL_SystemWindow);
				return;
			}
			DBKeepPosition pos = new DBKeepPosition();
			pos.ClassType = "DOL.GS.Keeps.GameKeepDoor";
			pos.TemplateType = doorIndex;
			pos.ComponentSkin = component.Skin;
			pos.ComponentRotation = component.ComponentHeading;
			pos.TemplateID = Guid.NewGuid().ToString();
			int x, y;

			SaveXY(component, player.X, player.Y, out x, out y);
			pos.XOff = x;
			pos.YOff = y;

			pos.ZOff = player.Z - component.Z;

			pos.HOff = player.Heading - component.Heading;

			GameServer.Database.AddObject(pos);

			player.Out.SendMessage("Added door as a position to keep.  A server restart will be required to load this position.", eChatType.CT_System, eChatLoc.CL_SystemWindow);
		}
示例#11
0
		public static void RemovePosition(DBKeepPosition position)
		{
			foreach (AbstractGameKeep keep in GameServer.KeepManager.GetAllKeeps())
			{
				foreach (GameKeepComponent component in keep.KeepComponents)
				{
					DBKeepPosition[] list = component.Positions[position.TemplateID] as DBKeepPosition[];
					if (list == null)
					{
						list = new DBKeepPosition[4];
						component.Positions[position.TemplateID] = list;
					}
					//list.SetValue(position, position.Height);
					list[position.Height] = null;
				}
			}
			GameServer.Database.DeleteObject(position);
		}
示例#12
0
		/// <summary>
		/// Creates a position
		/// </summary>
		/// <param name="templateID">The template ID</param>
		/// <param name="component">The component object</param>
		/// <param name="player">The creating player object</param>
		/// <returns>The position object</returns>
		public static DBKeepPosition CreatePosition(string templateID, GameKeepComponent component, GamePlayer player)
		{
			DBKeepPosition pos = new DBKeepPosition();
			pos.ComponentSkin = component.Skin;
			pos.ComponentRotation = component.ComponentHeading;
			pos.TemplateID = templateID;
			int x, y;

			SaveXY(component, player.X, player.Y, out x, out y);
			pos.XOff = x;
			pos.YOff = y;

			pos.ZOff = player.Z - component.Z;

			pos.HOff = player.Heading - component.Heading;
			return pos;
		}
示例#13
0
		public virtual void LoadFromPosition(DBKeepPosition pos, GameKeepComponent component)
		{
			m_templateID = pos.TemplateID;
			m_component = component;

			PositionMgr.LoadKeepItemPosition(pos, this);
			component.AbstractKeep.Doors[m_templateID] = this;

			m_oldMaxHealth = MaxHealth;
			m_health = MaxHealth;
			m_name = "Keep Door";
			m_oldHealthPercent = HealthPercent;
			m_doorID = GenerateDoorID();
			this.m_model = 0xFFFF;
			m_state = eDoorState.Closed;

			if (AddToWorld())
			{
				StartHealthRegeneration();
				DoorMgr.RegisterDoor(this);
			}
			else
			{
				log.Error("Failed to load keep door from position! DoorID=" + m_doorID + ". Component SkinID=" + component.Skin + ". KeepID=" + component.AbstractKeep.KeepID);
			}

		}
示例#14
0
		public void DeleteObject()
		{
			if (Component != null)
			{
				if (Component.AbstractKeep != null)
				{
					Component.AbstractKeep.Banners.Remove(this.ObjectID);
				}

				Component.Delete();
			}

			Component = null;
			Position = null;

			base.Delete();
			CurrentRegion = null;
		}
示例#15
0
		public void MoveToPosition(DBKeepPosition position)
		{
			PositionMgr.LoadKeepItemPosition(position, this);
			int zAdd = 1000;
			if (BannerType == eBannerType.Guild)
				zAdd = 1500;

			this.MoveTo(this.CurrentRegionID, this.X, this.Y, this.Z + zAdd, this.Heading);
		}
示例#16
0
		public virtual void LoadFromPosition(DBKeepPosition pos, GameKeepComponent component)
		{
			m_templateID = pos.TemplateID;
			m_component = component;
			BannerType = (eBannerType)pos.TemplateType;

			PositionMgr.LoadKeepItemPosition(pos, this);
			component.AbstractKeep.Banners[m_templateID] = this;
			if (BannerType == eBannerType.Guild)
			{
				if (component.AbstractKeep.Guild != null)
				{
					ChangeGuild();
					Z += 1500;
					this.AddToWorld();
				}
			}
			else
			{
				ChangeRealm();
				Z += 1000;	// this works around an issue where all banners are at keep level instead of on top
							// with a z value > height of the keep the banners show correctly - tolakram
				this.AddToWorld();
			}
		}
		public void MoveToPosition(DBKeepPosition position)
		{ }
示例#18
0
		public static void AddPosition(DBKeepPosition position)
		{
			foreach (AbstractGameKeep keep in KeepMgr.GetAllKeeps())
			{
				foreach (GameKeepComponent component in keep.KeepComponents)
				{
					DBKeepPosition[] list = component.Positions[position.TemplateID] as DBKeepPosition[];
					if (list == null)
					{
						list = new DBKeepPosition[4];
						component.Positions[position.TemplateID] = list;
					}
					//list.SetValue(position, position.Height);
					list[position.Height] = position;
				}
			}
		}