Overwrite

Complete Overwrite of the Folder with the free shard. ServUO 57.3 has been added.

Scripts/SubSystem/Pet Shrink/Replace.cs

@@ -0,0 +1,207 @@
+#region AuthorHeader
+//
+//	Replace version 1.0 - utilities version 2.0, by Xanthos
+//
+//
+#endregion AuthorHeader                                                                                                                                                                                                                                                               
+using System;
+using System.Collections;
+using System.Reflection;
+using Server;
+using Server.Network;
+using Server.Prompts;
+using Server.Items;
+using Server.Mobiles;
+using Server.Targeting;
+using System.IO;
+using System.Xml;
+using Server.Commands;
+using Server.Commands.Generic;
+
+namespace Xanthos.Utilities
+{
+	public class PickReplacementTarget : Target
+	{
+		private Item m_ItemToReplace;
+		private bool m_CopyDeep;
+
+		public static void Initialize()
+		{
+			CommandHandlers.Register( "ReplaceItem", AccessLevel.GameMaster, new CommandEventHandler( ReplaceItem_OnCommand ) );
+//			CommandHandlers.Register( "UpgradeShrinkSystem", AccessLevel.GameMaster, new CommandEventHandler( UpgradeShrinkSystem ) );
+		}
+
+		public PickReplacementTarget( object o, bool copyDeep ) : base( -1, false, TargetFlags.None )
+		{
+			m_ItemToReplace = o as Item;
+			m_CopyDeep = copyDeep;
+		}
+
+		[Usage( "ReplaceItem [-d]" )]
+		[Description( "Replaces an item with another copying properties of the replaced to the replacement." )]
+		private static void ReplaceItem_OnCommand( CommandEventArgs e )
+		{
+			bool copyDeep = false;
+
+			if ( e.Length == 1 && e.GetString( 0 ).Equals( "-d" ))
+				copyDeep = true;
+
+			e.Mobile.Target = new ReplaceItemTarget( copyDeep );
+			e.Mobile.SendMessage( "Choose an Item to replace." );
+		}
+
+		[Usage( "UpdateShrinkSystem" )]
+		[Description( "Updates the Items in the shrink system." )]
+		public static void UpgradeShrinkSystem( CommandEventArgs e )
+		{
+//			ReplaceType( "Xanthos.ShrinkSystem.PetLeash", "Xanthos.Evo.PetLeash", false );
+//			ReplaceType( "Xanthos.ShrinkSystem.HitchingPost", "Xanthos.Evo.HitchingPost", false );
+//			ReplaceType( "Xanthos.ShrinkSystem.ShrinkItem", "Xanthos.Evo.ShrinkItem", true );
+		}
+
+		protected override void OnTarget( Mobile from, object replacement )
+		{
+			if ( !( replacement is Item ))
+				from.SendMessage( "You cannot use that as a replacement!" );
+			else
+				ReplaceItem( replacement as Item, m_ItemToReplace, m_CopyDeep );
+		}
+
+		private static void CopyPropertiesShallow( Item dest, Item src ) 
+		{
+			dest.IsLockedDown = src.IsLockedDown;
+			dest.IsSecure = src.IsSecure;
+			dest.Movable = src.Movable;
+			dest.Insured = src.Insured;
+			dest.LootType = src.LootType;
+			dest.BlessedFor = src.BlessedFor;
+			dest.Name = src.Name;
+		}
+
+		private static void CopyProperties( Item dest, Item src ) 
+		{
+			Dupe.CopyProperties(src, dest);
+
+			// Must do this due to a bug in impl of Newbied, which comes after loottype
+			// in the props list, overwriting loottype.
+			dest.LootType = src.LootType;
+		}
+
+		//
+		// Search through all of the Items for those with Type oldTypeName
+		// and create Items of newTypeName passing the two Items to ReplaceItem()
+		//
+		private static void ReplaceType( string newTypeName, string oldTypeName, bool copyDeep )
+		{
+			Type oldType = null;
+			Type newType = null;
+
+			try
+			{
+				oldType = Type.GetType( oldTypeName );
+				newType = Type.GetType( newTypeName );
+			}
+			catch ( Exception e )
+			{
+				Console.WriteLine( "Exception getting types {0}", e.Message );
+			}
+
+			if ( oldType == null )
+				Console.WriteLine( "No class {0} installed", oldTypeName );
+			else if ( newType == null )
+				Console.WriteLine( "No class {0} installed", newTypeName );
+			else
+			{
+				Type[] types = new Type[0];
+				ConstructorInfo ci = newType.GetConstructor( types );
+
+				if ( ci != null )
+				{
+					ArrayList array = new ArrayList();
+
+					Console.WriteLine( "Looking for {0}s", oldTypeName );
+					foreach( Item item in World.Items.Values )
+					{
+						if ( item.GetType() == oldType )
+							array.Add( item );
+					}
+
+					Console.WriteLine( "Found {0} {1}s - replacing with {2}s", array.Count, oldTypeName, newTypeName );
+
+					for ( int j = 0; j < array.Count; j++ )
+					{
+						Item item = array[j] as Item;
+
+						if ( item != null && item.GetType() == oldType )
+						{
+							Object obj = ci.Invoke( null );
+
+							if ( obj == null )
+								continue;
+							
+							ReplaceItem( (Item)obj, item, copyDeep );	// This does the actual work of replacement
+						}
+					}
+					Console.WriteLine( "Replaced {0} {1} with {2}", array.Count, oldTypeName, newTypeName );
+				}
+			}
+		}
+
+		//
+		// Given two Items, copies the properties of the first to the second
+		// then places the second one where the first is and deletes the first.
+		//
+		public static void ReplaceItem( Item replacement, Item itemToReplace, bool copyDeep )
+		{
+			Container pack;
+
+			if ( null != itemToReplace && !itemToReplace.Deleted )
+			{
+				if ( copyDeep )
+					CopyProperties( replacement, itemToReplace );
+				else
+					CopyPropertiesShallow( replacement, itemToReplace );
+
+				if ( itemToReplace.Parent is Container )
+					pack = (Container)itemToReplace.Parent;
+				else if ( itemToReplace.Parent is Mobile )
+					pack = ((Mobile)itemToReplace.Parent).Backpack;
+				else
+					pack = null;
+
+				replacement.Internalize();
+
+				if ( pack != null )
+					pack.DropItem( replacement );
+				else
+					replacement.MoveToWorld( itemToReplace.Location, itemToReplace.Map );
+
+				itemToReplace.Delete();
+			}
+		}
+	}
+
+	public class ReplaceItemTarget : Target
+	{
+		bool m_CopyDeep;
+
+		public ReplaceItemTarget( bool copyDeep ) : base( -1, false, TargetFlags.None )
+		{
+			m_CopyDeep = copyDeep;
+		}
+
+		protected override void OnTarget( Mobile from, object o )
+		{
+			if ( o is Item )
+			{
+				from.Target = new PickReplacementTarget( o, m_CopyDeep );
+				from.SendMessage( "Choose a replacement." );
+			}
+			else
+				from.SendMessage( "You cannot replace that!" );
+		}
+	}
+}
+
+
+