Overwrite

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

Scripts/Services/XmlSpawner/XmlSpawner Core/XmlTextEntryBook.cs

@@ -0,0 +1,372 @@
+#define BOOKTEXTENTRY
+
+using System;
+using System.IO;
+using System.Text;
+using Server;
+using Server.Network;
+using Server.Mobiles;
+using Server.Gumps;
+
+namespace Server.Items
+{
+
+	public delegate void XmlTextEntryBookCallback( Mobile from, object [] args, string response );
+
+	public class XmlTextEntryBook : BaseEntryBook
+	{
+		public XmlTextEntryBookCallback m_bookcallback;
+		public object [] m_args;
+
+		public XmlTextEntryBook( int itemID, string title, string author, int pageCount, bool writable,
+			XmlTextEntryBookCallback callback, object [] args) : base( itemID, title, author, pageCount, writable )
+		{
+			m_args = args;
+			m_bookcallback = callback;
+		}
+
+		public XmlTextEntryBook( Serial serial ) : base( serial )
+		{
+		}
+
+		public void FillTextEntryBook(string text)
+		{
+
+			int pagenum = 0;
+			BookPageInfo [] pages = Pages;
+			int current = 0;
+
+			// break up the text into single line length pieces
+			while(text != null && current < text.Length)
+			{
+				int lineCount = 8;
+				string[] lines = new string[lineCount];
+
+				// place the line on the page
+				for(int i=0;i<lineCount;i++)
+				{
+					if(current < text.Length)
+					{
+						// make each line 25 chars long
+						int length = text.Length - current;
+						if(length > 20) length = 20;
+						lines[i] = text.Substring(current,length);
+						current += length;
+					} 
+					else 
+					{
+						// fill up the remaining lines
+						lines[i] = String.Empty;
+					}
+				}
+
+				if ( pagenum >= PagesCount )
+					return;
+				Pages[pagenum].Lines = lines;
+				pagenum++;
+			}
+			// empty the remaining contents
+			for(int j=pagenum;j < PagesCount; j++)
+			{
+				if(Pages[j].Lines.Length > 0)
+					for(int i=0;i<Pages[j].Lines.Length;i++)
+					{
+						Pages[j].Lines[i] = String.Empty;
+					}
+			}
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+			int version = reader.ReadInt();
+
+			Delete();
+		}
+	}
+
+	// -------------------------------------------------------------
+	// modifed from Beta-36 distribution version of BaseBook from basebook.cs
+	// adds a hook to allow processing of book text on content change
+	// -------------------------------------------------------------
+	public class BaseEntryBook : Item
+	{
+		private string m_Title;
+		private string m_Author;
+		private BookPageInfo[] m_Pages;
+		private bool m_Writable;
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public string Title
+		{
+			get { return m_Title; }
+			set { m_Title = value; InvalidateProperties(); }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public string Author
+		{
+			get { return m_Author; }
+			set { m_Author = value; InvalidateProperties(); }
+		}
+
+		[CommandProperty( AccessLevel.GameMaster )]
+		public bool Writable
+		{
+			get { return m_Writable; }
+			set { m_Writable = value; }
+		}
+
+		[CommandProperty(AccessLevel.GameMaster)]
+		public int PagesCount
+		{
+			get { return m_Pages.Length; }
+		}
+
+		public BookPageInfo[] Pages
+		{
+			get { return m_Pages; }
+		}
+
+		[Constructable]
+		public BaseEntryBook( int itemID, string title, string author, int pageCount, bool writable) : base( itemID )
+		{
+			m_Title = title;
+			m_Author = author;
+			m_Pages = new BookPageInfo[pageCount];
+			m_Writable = writable;
+
+			for ( int i = 0; i < m_Pages.Length; ++i )
+				m_Pages[i] = new BookPageInfo();
+		}
+
+		public BaseEntryBook( Serial serial ) : base( serial )
+		{
+		}
+
+		public override void Serialize( GenericWriter writer )
+		{
+			base.Serialize( writer );
+			writer.Write( (int) 0 ); // version
+		}
+
+		public override void Deserialize( GenericReader reader )
+		{
+			base.Deserialize( reader );
+			int version = reader.ReadInt();
+		}
+#if(BOOKTEXTENTRY)
+		public override void OnDoubleClick ( Mobile from )
+		{
+			from.Send( new EntryBookHeader( from, this ) );
+			from.Send( new EntryBookPageDetails( this ) );
+		}
+
+		public static void Initialize()
+		{
+			// This will hijack the default packet handler for basebooks content change.  The header change handlers are left alone and basebook will still handle them.
+			// This means that BaseEntryBooks will not support header changes (they are not intended to)
+
+			//PacketHandlers.Register( 0x66,  0, true, new OnPacketReceive( ContentChange ) );
+
+		}
+
+		public static void ContentChange( NetState state, PacketReader pvSrc )
+		{
+			// need to deal with actual books
+			string entryText = String.Empty;
+			Mobile from = state.Mobile;
+
+			int serial = pvSrc.ReadInt32();
+
+            Item bookitem = World.FindItem(serial);
+
+            // first try it as a normal basebook
+            if (bookitem is BaseBook)
+            {
+                // do the base book content change
+                BaseContentChange(bookitem as BaseBook, state, pvSrc);
+                return;
+            }
+
+            // then try it as a text entry book
+            BaseEntryBook book = bookitem as BaseEntryBook;
+
+            if (book == null) return;
+
+			// get the number of available pages in the book
+			int pageCount = pvSrc.ReadUInt16();
+
+			if ( pageCount > book.PagesCount )
+				return;
+
+			for ( int i = 0; i < pageCount; ++i )
+			{
+				// get the current page number being read
+				int index = pvSrc.ReadUInt16();
+
+				if ( index >= 1 && index <= book.PagesCount )
+				{
+					--index;
+
+					int lineCount = pvSrc.ReadUInt16();
+
+					if ( lineCount <= 8 )
+					{
+						string[] lines = new string[lineCount];
+
+						for ( int j = 0; j < lineCount; ++j )
+						{
+							if ( (lines[j] = pvSrc.ReadUTF8StringSafe()).Length >= 80 )
+								return;
+
+						}
+
+						book.Pages[index].Lines = lines;
+
+					}
+					else
+					{
+						return;
+					}
+				}
+				else
+				{
+					return;
+				}
+			}
+			System.Text.StringBuilder sb = new System.Text.StringBuilder();
+			// add the book lines to the entry string
+			for ( int i = 0; i < book.PagesCount; ++i )
+			{
+				for(int j=0;j<book.Pages[i].Lines.Length;j++)
+				{
+					sb.Append(book.Pages[i].Lines[j]);
+				}
+			}
+
+			// send the book text off to be processed by invoking the callback if it is a textentry book
+			XmlTextEntryBook tebook = book as XmlTextEntryBook;
+			if(tebook != null && tebook.m_bookcallback != null)
+			{
+				tebook.m_bookcallback(state.Mobile, tebook.m_args, sb.ToString());
+			}
+		}
+
+        public static void BaseContentChange(BaseBook book, NetState state, PacketReader pvSrc)
+        {
+            Mobile from = state.Mobile;
+
+            if (book == null)
+                return;
+
+            int pageCount = pvSrc.ReadUInt16();
+
+            if (state.IsEnhancedClient && pageCount == 1)
+            {
+                book.ContentChangeEC(state, pvSrc);
+                return;
+            }
+            else if (book.Writable && from.InRange(book.GetWorldLocation(), 1))
+            {
+                if (pageCount > book.PagesCount)
+                    return;
+
+                for (int i = 0; i < pageCount; ++i)
+                {
+                    int index = pvSrc.ReadUInt16();
+
+                    if (index >= 1 && index <= book.PagesCount)
+                    {
+                        --index;
+
+                        int lineCount = pvSrc.ReadUInt16();
+
+                        if (lineCount <= 8)
+                        {
+                            string[] lines = new string[lineCount];
+
+                            for (int j = 0; j < lineCount; ++j)
+                                if ((lines[j] = pvSrc.ReadUTF8StringSafe()).Length >= 80)
+                                    return;
+
+                            book.Pages[index].Lines = lines;
+                        }
+                        else
+                        {
+                            return;
+                        }
+                    }
+                    else
+                    {
+                        return;
+                    }
+                }
+            }
+        }
+#endif
+	}
+
+#if(BOOKTEXTENTRY)
+	public sealed class EntryBookPageDetails : Packet
+	{
+		public EntryBookPageDetails( BaseEntryBook book ) : base( 0x66 )
+		{
+			EnsureCapacity( 256 );
+
+			m_Stream.Write( (int)    book.Serial );
+			m_Stream.Write( (ushort) book.PagesCount );
+
+			for ( int i = 0; i < book.PagesCount; ++i )
+			{
+				BookPageInfo page = book.Pages[i];
+
+				m_Stream.Write( (ushort) (i + 1) );
+				m_Stream.Write( (ushort) page.Lines.Length );
+
+				for ( int j = 0; j < page.Lines.Length; ++j )
+				{
+					byte[] buffer = Utility.UTF8.GetBytes( page.Lines[j] );
+
+					m_Stream.Write( buffer, 0, buffer.Length );
+					m_Stream.Write( (byte) 0 );
+				}
+			}
+		}
+	}
+
+	public sealed class EntryBookHeader : Packet
+	{
+		public EntryBookHeader( Mobile from, BaseEntryBook book ) : base ( 0xD4 )
+		{
+			string title = book.Title == null ? "" : book.Title;
+			string author = book.Author == null ? "" : book.Author;
+
+			byte[] titleBuffer = Utility.UTF8.GetBytes( title );
+			byte[] authorBuffer = Utility.UTF8.GetBytes( author );
+
+			EnsureCapacity( 15 + titleBuffer.Length + authorBuffer.Length );
+
+			m_Stream.Write( (int)    book.Serial );
+			m_Stream.Write( (bool)   true );
+			m_Stream.Write( (bool)   book.Writable && from.InRange( book.GetWorldLocation(), 1 ) );
+			m_Stream.Write( (ushort) book.PagesCount );
+
+			m_Stream.Write( (ushort) (titleBuffer.Length + 1) );
+			m_Stream.Write( titleBuffer, 0, titleBuffer.Length );
+			m_Stream.Write( (byte) 0 ); // terminate
+
+			m_Stream.Write( (ushort) (authorBuffer.Length + 1) );
+			m_Stream.Write( authorBuffer, 0, authorBuffer.Length );
+			m_Stream.Write( (byte) 0 ); // terminate
+		}
+	}
+#endif
+}
+