context: using System;
  using System.Collections;
  using System.Linq;
  using System.Net;
  using System.Net.Sockets;
  
  using Server;
  using Server.Engines.Housing;
  using Server.Engines.Housing.Items;
  using Server.Items;
  using Server.Gumps;
  using Server.Spells;
  using Server.Multis;
  using Server.Mobiles;
  using Server.Network;
  using Server.Accounting;
  
  namespace Server.Scripts.Commands
  {
  	public class TargetCommands
  	{
  		public static void Initialize()
  		{
  			Register( new KillCommand( true ) );
  			Register( new KillCommand( false ) );
  			Register( new HideCommand( true ) );
  			Register( new HideCommand( false ) );
  			Register( new KickCommand( true ) );
  			Register( new KickCommand( false ) );
  			Register( new FirewallCommand() );
  			Register( new TeleCommand() );
  			Register( new SetCommand() );
  			Register( new AliasedSetCommand( AccessLevel.GameMaster, "Immortal", "blessed", "true", ObjectTypes.Mobiles ) );
  			Register( new AliasedSetCommand( AccessLevel.GameMaster, "Invul", "blessed", "true", ObjectTypes.Mobiles ) );
  			Register( new AliasedSetCommand( AccessLevel.GameMaster, "Mortal", "blessed", "false", ObjectTypes.Mobiles ) );
  			Register( new AliasedSetCommand( AccessLevel.GameMaster, "NoInvul", "blessed", "false", ObjectTypes.Mobiles ) );
  			Register( new AliasedSetCommand( AccessLevel.GameMaster, "Squelch", "squelched", "true", ObjectTypes.Mobiles ) );
  			Register( new AliasedSetCommand( AccessLevel.GameMaster, "Unsquelch", "squelched", "false", ObjectTypes.Mobiles ) );
  			Register( new GetCommand() );
  			Register( new GetTypeCommand() );
  			Register( new DeleteCommand() );
  			Register( new RestockCommand() );
  			Register( new DismountCommand() );
  			Register( new AddCommand() );
  			Register( new AddToPackCommand() );
  			Register( new TellCommand() );
  			Register( new PrivSoundCommand() );
  			Register( new IncreaseCommand() );
  			Register( new OpenBrowserCommand() );
  			Register( new CountCommand() );
  			Register( new InterfaceCommand() );
  			Register( new RefreshHouseCommand() );
  			Register( new ConditionCommand() );
  			Register( new Factions.FactionKickCommand( Factions.FactionKickType.Kick ) );
  			Register( new Factions.FactionKickCommand( Factions.FactionKickType.Ban ) );
  			Register( new Factions.FactionKickCommand( Factions.FactionKickType.Unban ) );
  			Register( new BringToPackCommand() );
  		}
  
  		private static ArrayList m_AllCommands = new ArrayList();
  
  		public static ArrayList AllCommands { get { return m_AllCommands; } }
  
  		public static void Register( BaseCommand command )
  		{
  			m_AllCommands.Add( command );
  
  			ArrayList impls = BaseCommandImplementor.Implementors;
  
  			for ( int i = 0; i < impls.Count; ++i )
  			{
  				BaseCommandImplementor impl = (BaseCommandImplementor) impls[i];
  
  				if ( ( command.Supports & impl.SupportRequirement ) != 0 )
  				{
  					impl.Register( command );
  				}
  			}
  		}
  	}
  
  	public class ConditionCommand : BaseCommand
  	{
  		public ConditionCommand()
  		{
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.Simple | CommandSupport.Complex | CommandSupport.Self;
  			Commands = new string[] { "Condition" };
  			ObjectTypes = ObjectTypes.All;
  			Usage = "Condition <condition>";
  			Description = "Checks that the given condition matches a targeted object.";
  			ListOptimized = true;
  		}
  
  		public override void ExecuteList( CommandEventArgs e, ArrayList list )
  		{
  			try
  			{
  				string[] args = e.Arguments;
  				ObjectConditional condition = ObjectConditional.Parse( e.Mobile, ref args );
  
  				for ( int i = 0; i < list.Count; ++i )
  				{
  					if ( condition.CheckCondition( list[i] ) )
  					{
  						AddResponse( "True - that object matches the condition." );
  					}
  					else
  					{
  						AddResponse( "False - that object does not match the condition." );
  					}
  				}
  			}
  			catch ( Exception ex )
  			{
  				e.Mobile.SendMessage( ex.Message );
  			}
  		}
  	}
  
  	public class BringToPackCommand : BaseCommand
  	{
  		public BringToPackCommand()
  		{
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.AllItems;
  			Commands = new string[] { "BringToPack" };
  			ObjectTypes = ObjectTypes.Items;
  			Usage = "BringToPack";
  			Description = "Brings a targeted item to your backpack.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			Item item = obj as Item;
  
  			if ( item != null )
  			{
  				if ( e.Mobile.PlaceInBackpack( item ) )
  				{
  					AddResponse( "The item has been placed in your backpack." );
  				}
  				else
  				{
  					AddResponse( "Your backpack could not hold the item." );
  				}
  			}
  		}
  	}
  
  	public class RefreshHouseCommand : BaseCommand
  	{
  		public RefreshHouseCommand()
  		{
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.Simple;
  			Commands = new string[] { "RefreshHouse" };
  			ObjectTypes = ObjectTypes.Items;
  			Usage = "RefreshHouse";
  			Description = "Refreshes a targeted house sign.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			if ( obj is HouseSign )
  			{
  				IHouse house = ( (HouseSign) obj ).Owner;
  
  				if ( house == null )
  				{
  					LogFailure( "That sign has no house attached." );
  				}
  				else
  				{
  					house.RefreshDecay();
  					AddResponse( "The house has been refreshed." );
  				}
  			}
  			else
  			{
  				LogFailure( "That is not a house sign." );
  			}
  		}
  	}
  
  	public class CountCommand : BaseCommand
  	{
  		public CountCommand()
  		{
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.Complex;
  			Commands = new string[] { "Count" };
  			ObjectTypes = ObjectTypes.All;
  			Usage = "Count";
  			Description = "Counts the number of objects that a command modifier would use. Generally used with condition arguments.";
  			ListOptimized = true;
  		}
  
  		public override void ExecuteList( CommandEventArgs e, ArrayList list )
  		{
  			if ( list.Count == 1 )
  			{
  				AddResponse( "There is one matching object." );
  			}
  			else
  			{
  				AddResponse( String.Format( "There are {0} matching objects.", list.Count ) );
  			}
  		}
  	}
  
  	public class OpenBrowserCommand : BaseCommand
  	{
  		public OpenBrowserCommand()
  		{
  			AccessLevel = AccessLevel.Counselor;
  			Supports = CommandSupport.AllMobiles;
  			Commands = new string[] { "OpenBrowser", "OB" };
  			ObjectTypes = ObjectTypes.Mobiles;
  			Usage = "OpenBrowser <url>";
  			Description = "Opens the web browser of a targeted player to a specified url.";
  		}
  
  		public static void OpenBrowser_Callback( Mobile from, bool okay, object state )
  		{
  			object[] states = (object[]) state;
  			Mobile gm = (Mobile) states[0];
  			string url = (string) states[1];
  
  			if ( okay )
  			{
  				gm.SendMessage( "{0} : has opened their web browser to : {1}", from.Name, url );
  				from.LaunchBrowser( url );
  			}
  			else
  			{
  				from.SendMessage( "You have chosen not to open your web browser." );
  				gm.SendMessage( "{0} : has chosen not to open their web browser to : {1}", from.Name, url );
  			}
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			if ( e.Length == 1 )
  			{
  				Mobile mob = (Mobile) obj;
  				Mobile from = e.Mobile;
  
  				if ( mob.IsPlayer )
  				{
  					GameClient ns = mob.Client;
  
  					if ( ns == null )
  					{
  						LogFailure( "That player is not online." );
  					}
  					else
  					{
  						string url = e.GetString( 0 );
  
  						CommandLogging.WriteLine( from, "{0} {1} requesting to open web browser of {2} to {3}", from.AccessLevel, CommandLogging.Format( from ), CommandLogging.Format( mob ), url );
  						AddResponse( "Awaiting user confirmation..." );
  						mob.SendGump( new WarningGump( 1060637, 30720, String.Format( "A game master is requesting to open your web browser to the following URL:<br>{0}", url ), 0xFFC000, 320, 240, new WarningGumpCallback( OpenBrowser_Callback ), new object[] { from, url } ) );
  					}
  				}
  				else
  				{
  					LogFailure( "That is not a player." );
  				}
  			}
  			else
  			{
  				LogFailure( "Format: OpenBrowser <url>" );
  			}
  		}
  	}
  
  	public class IncreaseCommand : BaseCommand
  	{
  		public IncreaseCommand()
  		{
  			AccessLevel = AccessLevel.Counselor;
  			Supports = CommandSupport.All;
  			Commands = new string[] { "Increase", "Inc" };
  			ObjectTypes = ObjectTypes.Both;
  			Usage = "Increase {<propertyName> <offset> ...}";
  			Description = "Increases the value of a specified property by the specified offset.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			if ( obj is BaseMulti )
  			{
  				LogFailure( "This command does not work on multis." );
  			}
  			else if ( e.Length >= 2 )
  			{
  				string result = Properties.IncreaseValue( e.Mobile, obj, e.Arguments );
  
  				if ( result == "The property has been increased." || result == "The properties have been increased." || result == "The property has been decreased." || result == "The properties have been decreased." || result == "The properties have been changed." )
  				{
  					AddResponse( result );
  				}
  				else
  				{
  					LogFailure( result );
  				}
  			}
  			else
  			{
  				LogFailure( "Format: Increase {<propertyName> <offset> ...}" );
  			}
  		}
  	}
  
  	public class PrivSoundCommand : BaseCommand
  	{
  		public PrivSoundCommand()
  		{
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.AllMobiles;
  			Commands = new string[] { "PrivSound" };
  			ObjectTypes = ObjectTypes.Mobiles;
  			Usage = "PrivSound <index>";
  			Description = "Plays a sound to a given target.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			Mobile from = e.Mobile;
  
  			if ( e.Length == 1 )
  			{
  				int index = e.GetInt32( 0 );
  				Mobile mob = (Mobile) obj;
  
  				CommandLogging.WriteLine( from, "{0} {1} playing sound {2} for {3}", from.AccessLevel, CommandLogging.Format( from ), index, CommandLogging.Format( mob ) );
  				mob.Send( GenericPackets.PlaySound( index, mob.Location ) );
  			}
  			else
  			{
  				from.SendMessage( "Format: PrivSound <index>" );
  			}
  		}
  	}
  
  	public class TellCommand : BaseCommand
  	{
  		public TellCommand()
  		{
  			AccessLevel = AccessLevel.Counselor;
  			Supports = CommandSupport.AllMobiles;
  			Commands = new string[] { "Tell" };
  			ObjectTypes = ObjectTypes.Mobiles;
  			Usage = "Tell \"text\"";
  			Description = "Sends a system message to a targeted player.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			Mobile mob = (Mobile) obj;
  			Mobile from = e.Mobile;
  
  			CommandLogging.WriteLine( from, "{0} {1} telling {2} \"{3}\"", from.AccessLevel, CommandLogging.Format( from ), CommandLogging.Format( mob ), e.ArgString );
  
  			mob.SendMessage( e.ArgString );
  		}
  	}
  
  	public class AddToPackCommand : BaseCommand
  	{
  		public AddToPackCommand()
  		{
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.All;
  			Commands = new string[] { "AddToPack", "AddToCont" };
  			ObjectTypes = ObjectTypes.Both;
  			ListOptimized = true;
  			Usage = "AddToPack <name> [params] [set {<propertyName> <value> ...}]";
  			Description = "Adds an item by name to the backpack of a targeted player or npc, or a targeted container. Optional constructor parameters. Optional set property list.";
  		}
  
  		public override void ExecuteList( CommandEventArgs e, ArrayList list )
  		{
  			ArrayList packs = new ArrayList( list.Count );
  
  			for ( int i = 0; i < list.Count; ++i )
  			{
  				object obj = list[i];
  				Container cont = null;
  
  				if ( obj is Mobile )
  				{
  					cont = ( (Mobile) obj ).Backpack;
  				}
  				else if ( obj is Container )
  				{
  					cont = (Container) obj;
  				}
  
  				if ( cont != null )
  				{
  					packs.Add( cont );
  				}
  				else
  				{
  					LogFailure( "That is not a container." );
  				}
  			}
  
  			Add.Invoke( e.Mobile, e.Mobile.Location, e.Mobile.Location, e.Arguments, packs );
  		}
  	}
  
  	public class AddCommand : BaseCommand
  	{
  		public AddCommand()
  		{
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.Simple | CommandSupport.Self;
  			Commands = new string[] { "Add" };
  			ObjectTypes = ObjectTypes.All;
  			Usage = "Add [<name> [params] [set {<propertyName> <value> ...}]]";
  			Description = "Adds an item or npc by name to a targeted location. Optional constructor parameters. Optional set property list. If no arguments are specified, this brings up a categorized add menu.";
  		}
  
  		public override bool ValidateArgs( BaseCommandImplementor impl, CommandEventArgs e )
  		{
  			if ( e.Length >= 1 )
  			{
  				Type t = ScriptCompiler.FindTypeByName( e.GetString( 0 ) );
  
  				if ( t == null )
  				{
  					e.Mobile.SendMessage( "No type with that name was found." );
  
  					string match = e.GetString( 0 ).Trim();
  
  					if ( match.Length < 3 )
  					{
  						e.Mobile.SendMessage( "Invalid search string." );
  						e.Mobile.SendGump( new Server.Gumps.AddGump( e.Mobile, match, 0, Type.EmptyTypes, false ) );
  					}
  					else
  					{
  						e.Mobile.SendGump( new Server.Gumps.AddGump( e.Mobile, match, 0, (Type[]) Server.Gumps.AddGump.Match( match ).ToArray( typeof( Type ) ), true ) );
  					}
  				}
  				else
  				{
  					return true;
  				}
  			}
  			else
  			{
  				e.Mobile.SendGump( new Server.Gumps.CategorizedAddGump( e.Mobile ) );
  			}
  
  			return false;
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			IPoint3D p = obj as IPoint3D;
  
  			if ( p == null )
  			{
  				return;
  			}
  
  			if ( p is Item )
  			{
  				p = ( (Item) p ).GetWorldTop();
  			}
  			else if ( p is Mobile )
  			{
  				p = ( (Mobile) p ).Location;
  			}
  
  			Add.Invoke( e.Mobile, new Point3D( p ), new Point3D( p ), e.Arguments );
  		}
  	}
  
  	public class TeleCommand : BaseCommand
  	{
  		public TeleCommand()
  		{
  			AccessLevel = AccessLevel.Counselor;
  			Supports = CommandSupport.Simple;
  			Commands = new string[] { "Teleport", "Tele" };
  			ObjectTypes = ObjectTypes.All;
  			Usage = "Teleport";
  			Description = "Teleports your character to a targeted location.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			IPoint3D p = obj as IPoint3D;
  
  			if ( p == null )
  			{
  				return;
  			}
  
  			Mobile from = e.Mobile;
  
  			SpellHelper.GetSurfaceTop( ref p );
  
  			CommandLogging.WriteLine( from, "{0} {1} teleporting to {2}", from.AccessLevel, CommandLogging.Format( from ), new Point3D( p ) );
  
  			Point3D fromLoc = from.Location;
  			Point3D toLoc = new Point3D( p );
  
  			from.Location = toLoc;
  			from.ProcessDelta();
  
  			if ( !from.Hidden )
  			{
  				Effects.SendLocationParticles( EffectItem.Create( fromLoc, from.Map, EffectItem.DefaultDuration ), 0x3728, 10, 10, 2023 );
  				Effects.SendLocationParticles( EffectItem.Create( toLoc, from.Map, EffectItem.DefaultDuration ), 0x3728, 10, 10, 5023 );
  
  				from.PlaySound( 0x1FE );
  			}
  		}
  	}
  
  	public class DismountCommand : BaseCommand
  	{
  		public DismountCommand()
  		{
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.AllMobiles;
  			Commands = new string[] { "Dismount" };
  			ObjectTypes = ObjectTypes.Mobiles;
  			Usage = "Dismount";
  			Description = "Forcefully dismounts a given target.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			Mobile from = e.Mobile;
  			Mobile mob = (Mobile) obj;
  
  			CommandLogging.WriteLine( from, "{0} {1} dismounting {2}", from.AccessLevel, CommandLogging.Format( from ), CommandLogging.Format( mob ) );
  
  			bool takenAction = false;
  
  			foreach ( var mountItem in mob.GetEquippedItems().OfType<MountItem>() )
  			{
  				IMount mount = mountItem.Mount;
  
  				if ( mount != null )
  				{
  					mount.Rider = null;
  					takenAction = true;
  				}
  			}
  
  			foreach ( var item in mob.GetEquippedItems() )
  			{
  				if ( item.Layer == Layer.Mount )
  				{
  					takenAction = true;
  					item.Delete();
  				}
  			}
  
  			if ( takenAction )
  				AddResponse( "They have been dismounted." );
  			else
  				LogFailure( "They were not mounted." );
  		}
  	}
  
  	public class RestockCommand : BaseCommand
  	{
  		public RestockCommand()
  		{
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.AllNPCs;
  			Commands = new string[] { "Restock" };
  			ObjectTypes = ObjectTypes.Mobiles;
  			Usage = "Restock";
  			Description = "Manually restocks a targeted vendor, refreshing the quantity of every item the vendor sells to the maximum. This also invokes the maximum quantity adjustment algorithms.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			if ( obj is BaseVendor )
  			{
  				CommandLogging.WriteLine( e.Mobile, "{0} {1} restocking {2}", e.Mobile.AccessLevel, CommandLogging.Format( e.Mobile ), CommandLogging.Format( obj ) );
  
  				( (BaseVendor) obj ).Restock();
  				AddResponse( "The vendor has been restocked." );
  			}
  			else
  			{
  				AddResponse( "That is not a vendor." );
  			}
  		}
  	}
  
  	public class GetTypeCommand : BaseCommand
  	{
  		public GetTypeCommand()
  		{
  			AccessLevel = AccessLevel.Counselor;
  			Supports = CommandSupport.All;
  			Commands = new string[] { "GetType" };
  			ObjectTypes = ObjectTypes.All;
  			Usage = "GetType";
  			Description = "Gets the type name of a targeted object.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			if ( obj == null )
  			{
  				AddResponse( "The object is null." );
  			}
  			else
  			{
  				Type type = obj.GetType();
  
  				if ( type.DeclaringType == null )
  				{
  					AddResponse( String.Format( "The type of that object is {0}.", type.Name ) );
  				}
  				else
  				{
  					AddResponse( String.Format( "The type of that object is {0}.", type.FullName ) );
  				}
  			}
  		}
  	}
  
  	public class GetCommand : BaseCommand
  	{
  		public GetCommand()
  		{
  			AccessLevel = AccessLevel.Counselor;
  			Supports = CommandSupport.All;
  			Commands = new string[] { "Get" };
  			ObjectTypes = ObjectTypes.All;
  			Usage = "Get <propertyName>";
  			Description = "Gets one or more property values by name of a targeted object.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			if ( e.Length >= 1 )
  			{
  				for ( int i = 0; i < e.Length; ++i )
  				{
  					string result = Properties.GetValue( e.Mobile, obj, e.GetString( i ) );
  
  					if ( result == "Property not found." || result == "Property is write only." || result.StartsWith( "Getting this property" ) )
  					{
  						LogFailure( result );
  					}
  					else
  					{
  						AddResponse( result );
  					}
  				}
  			}
  			else
  			{
  				LogFailure( "Format: Get <propertyName>" );
  			}
  		}
  	}
  
  	public class AliasedSetCommand : BaseCommand
  	{
  		private string m_Name;
  		private string m_Value;
  
  		public AliasedSetCommand( AccessLevel level, string command, string name, string value, ObjectTypes objects )
  		{
  			m_Name = name;
  			m_Value = value;
  
  			AccessLevel = level;
  
  			if ( objects == ObjectTypes.Items )
  			{
  				Supports = CommandSupport.AllItems;
  			}
  			else if ( objects == ObjectTypes.Mobiles )
  			{
  				Supports = CommandSupport.AllMobiles;
  			}
  			else
  			{
  				Supports = CommandSupport.All;
  			}
  
  			Commands = new string[] { command };
  			ObjectTypes = objects;
  			Usage = command;
  			Description = String.Format( "Sets the {0} property to {1}.", name, value );
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			string result = Properties.SetValue( e.Mobile, obj, m_Name, m_Value );
  
  			if ( result == "Property has been set." )
  			{
  				AddResponse( result );
  			}
  			else
  			{
  				LogFailure( result );
  			}
  		}
  	}
  
  	public class SetCommand : BaseCommand
  	{
  		public SetCommand()
  		{
  			AccessLevel = AccessLevel.Counselor;
  			Supports = CommandSupport.All;
  			Commands = new string[] { "Set" };
  			ObjectTypes = ObjectTypes.Both;
  			Usage = "Set <propertyName> <value> [...]";
  			Description = "Sets one or more property values by name of a targeted object.";
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			if ( e.Length >= 2 )
  			{
  				for ( int i = 0; ( i + 1 ) < e.Length; i += 2 )
  				{
  					string result = Properties.SetValue( e.Mobile, obj, e.GetString( i ), e.GetString( i + 1 ) );
  
  					if ( result == "Property has been set." )
  					{
  						AddResponse( result );
  					}
  					else
  					{
  						LogFailure( result );
  					}
  				}
  			}
  			else
  			{
  				LogFailure( "Format: Set <propertyName> <value>" );
  			}
  		}
  	}
  
  	public class DeleteCommand : BaseCommand
  	{
  		public DeleteCommand()
  		{
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.AllNPCs | CommandSupport.AllItems;
  			Commands = new string[] { "Delete", "Remove" };
  			ObjectTypes = ObjectTypes.Both;
  			Usage = "Delete";
  			Description = "Deletes a targeted item or mobile. Does not delete players.";
  		}
  
  		private void OnConfirmCallback( Mobile from, bool okay, object state )
  		{
  			object[] states = (object[]) state;
  			CommandEventArgs e = (CommandEventArgs) states[0];
  			ArrayList list = (ArrayList) states[1];
  
  			bool flushToLog = false;
  
  			if ( okay )
  			{
  				AddResponse( "Delete command confirmed." );
  
  				if ( list.Count > 20 )
  				{
  					CommandLogging.Enabled = false;
  				}
  
  				base.ExecuteList( e, list );
  
  				if ( list.Count > 20 )
  				{
  					flushToLog = true;
  					CommandLogging.Enabled = true;
  				}
  			}
  			else
  			{
  				AddResponse( "Delete command aborted." );
  			}
  
  			Flush( from, flushToLog );
  		}
  
  		public override void ExecuteList( CommandEventArgs e, ArrayList list )
  		{
  			if ( list.Count > 1 )
  			{
  				e.Mobile.SendGump( new WarningGump( 1060637, 30720, String.Format( "You are about to delete {0} objects. This cannot be undone without a full server revert.<br><br>Continue?", list.Count ), 0xFFC000, 420, 280, new WarningGumpCallback( OnConfirmCallback ), new object[] { e, list } ) );
  				AddResponse( "Awaiting confirmation..." );
  			}
  			else
  			{
  				base.ExecuteList( e, list );
  			}
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			if ( obj is Item )
  			{
  				CommandLogging.WriteLine( e.Mobile, "{0} {1} deleting {2}", e.Mobile.AccessLevel, CommandLogging.Format( e.Mobile ), CommandLogging.Format( obj ) );
  				( (Item) obj ).Delete();
  				AddResponse( "The item has been deleted." );
  			}
  			else if ( obj is Mobile && !( (Mobile) obj ).IsPlayer )
  			{
  				CommandLogging.WriteLine( e.Mobile, "{0} {1} deleting {2}", e.Mobile.AccessLevel, CommandLogging.Format( e.Mobile ), CommandLogging.Format( obj ) );
  				( (Mobile) obj ).Delete();
  				AddResponse( "The mobile has been deleted." );
  			}
  			else
  			{
  				LogFailure( "That cannot be deleted." );
  			}
  		}
  	}
  
  	public class KillCommand : BaseCommand
  	{
  		private bool m_Value;
  
  		public KillCommand( bool value )
  		{
  			m_Value = value;
  
  			AccessLevel = AccessLevel.GameMaster;
  			Supports = CommandSupport.AllMobiles;
  			Commands = value ? new string[] { "Kill" } : new string[] { "Resurrect", "Res" };
  			ObjectTypes = ObjectTypes.Mobiles;
  
  			if ( value )
  			{
  				Usage = "Kill";
  				Description = "Kills a targeted player or npc.";
  			}
  			else
  			{
  				Usage = "Resurrect";
  				Description = "Resurrects a targeted ghost.";
  			}
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			Mobile mob = (Mobile) obj;
  			Mobile from = e.Mobile;
  
  			if ( m_Value )
  			{
  				if ( !mob.Alive )
  				{
  					LogFailure( "They are already dead." );
  				}
  				else if ( !mob.CanBeDamaged() )
  				{
  					LogFailure( "They cannot be harmed." );
  				}
  				else
  				{
  					CommandLogging.WriteLine( from, "{0} {1} killing {2}", from.AccessLevel, CommandLogging.Format( from ), CommandLogging.Format( mob ) );
  					mob.Kill();
  
  					AddResponse( "They have been killed." );
  				}
  			}
  			else
  			{
  				if ( mob.IsDeadBondedPet )
  				{
  					BaseCreature bc = mob as BaseCreature;
  
  					if ( bc != null )
  					{
  						CommandLogging.WriteLine( from, "{0} {1} resurrecting {2}", from.AccessLevel, CommandLogging.Format( from ), CommandLogging.Format( mob ) );
  
  						bc.PlaySound( 0x214 );
  						bc.FixedEffect( 0x376A, 10, 16 );
  
  						bc.ResurrectPet();
  
  						AddResponse( "It has been resurrected." );
  					}
  				}
  				else if ( !mob.Alive )
  				{
  					CommandLogging.WriteLine( from, "{0} {1} resurrecting {2}", from.AccessLevel, CommandLogging.Format( from ), CommandLogging.Format( mob ) );
  
  					mob.PlaySound( 0x214 );
  					mob.FixedEffect( 0x376A, 10, 16 );
  
  					mob.Resurrect();
  
  					AddResponse( "They have been resurrected." );
  				}
  				else
  				{
  					LogFailure( "They are not dead." );
  				}
  			}
  		}
  	}
  
  	public class HideCommand : BaseCommand
  	{
  		private bool m_Value;
  
  		public HideCommand( bool value )
  		{
  			m_Value = value;
  
  			AccessLevel = AccessLevel.Counselor;
  			Supports = CommandSupport.AllMobiles;
  			Commands = new string[] { value ? "Hide" : "Unhide" };
  			ObjectTypes = ObjectTypes.Mobiles;
  
  			if ( value )
  			{
  				Usage = "Hide";
  				Description = "Makes a targeted mobile disappear in a puff of smoke.";
  			}
  			else
  			{
  				Usage = "Unhide";
  				Description = "Makes a targeted mobile appear in a puff of smoke.";
  			}
  		}
  
  		public override void Execute( CommandEventArgs e, object obj )
  		{
  			Mobile m = (Mobile) obj;
  
  			CommandLogging.WriteLine( e.Mobile, "{0} {1} {2} {3}", e.Mobile.AccessLevel, CommandLogging.Format( e.Mobile ), m_Value ? "hiding" : "unhiding", CommandLogging.Format( m ) );
  
  			Effects.SendLocationEffect( new Point3D( m.X + 1, m.Y, m.Z + 4 ), m.Map, 0x3728, 13 );
  			Effects.SendLocationEffect( new Point3D( m.X + 1, m.Y, m.Z ), m.Map, 0x3728, 13 );
  			Effects.SendLocationEffect( new Point3D( m.X + 1, m.Y, m.Z - 4 ), m.Map, 0x3728, 13 );
  			Effects.SendLocationEffect( new Point3D( m.X, m.Y + 1, m.Z + 4 ), m.Map, 0x3728, 13 );
  			Effects.SendLocationEffect( new Point3D( m.X, m.Y + 1, m.Z ), m.Map, 0x3728, 13 );
  			Effects.SendLocationEffect( new Point3D( m.X, m.Y + 1, m.Z - 4 ), m.Map, 0x3728, 13 );
  
  			Effects.SendLocationEffect( new Point3D( m.X + 1, m.Y + 1, m.Z + 11 ), m.Map, 0x3728, 13 );
  			Effects.SendLocationEffect( new Point3D( m.X + 1, m.Y + 1, m.Z + 7 ), m.Map, 0x3728, 13 );
  			Effects.SendLocationEffect( new Point3D( m.X + 1, m.Y + 1, m.Z + 3 ), m.Map, 0x3728, 13 );
  			Effects.SendLocationEffect( new Point3D( m.X + 1, m.Y + 1, m.Z - 1 ), m.Map, 0x3728, 13 );
  
  			m.PlaySound( 0x228 );
  			m.Hidden = m_Value;
  
  			if ( m_Value )
  			{
  
gt: 				AddResponse( "They have been hidden." );