Overwrite

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

Scripts/Items/Books/BaseBook.cs

@@ -0,0 +1,669 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text;
+using Server.ContextMenus;
+using Server.Gumps;
+using Server.Multis;
+using Server.Network;
+
+namespace Server.Items
+{
+    public class BookPageInfo
+    {
+        private string[] m_Lines;
+
+        public string[] Lines
+        {
+            get
+            {
+                return m_Lines;
+            }
+            set
+            {
+                m_Lines = value;
+            }
+        }
+
+        public BookPageInfo()
+        {
+            m_Lines = new string[0];
+        }
+
+        public BookPageInfo(params string[] lines)
+        {
+            m_Lines = lines;
+        }
+
+        public BookPageInfo(GenericReader reader)
+        {
+            int length = reader.ReadInt();
+
+            m_Lines = new string[length];
+
+            for (int i = 0; i < m_Lines.Length; ++i)
+                m_Lines[i] = Utility.Intern(reader.ReadString());
+        }
+
+        public void Serialize(GenericWriter writer)
+        {
+            writer.Write(m_Lines.Length);
+
+            for (int i = 0; i < m_Lines.Length; ++i)
+                writer.Write(m_Lines[i]);
+        }
+    }
+
+    public class BaseBook : Item, ISecurable
+    {
+        private string m_Title;
+        private string m_Author;
+        private BookPageInfo[] m_Pages;
+        private bool m_Writable;
+        private SecureLevel m_SecureLevel;
+		
+        [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 string BookString
+        {
+            get { return ContentAsString; }
+            set { BuildBookFromString(value); }
+        }
+
+        public BookPageInfo[] Pages
+        {
+            get
+            {
+                return m_Pages;
+            }
+        }
+
+        [Constructable]
+        public BaseBook(int itemID)
+            : this(itemID, 20, true)
+        {
+        }
+
+        [Constructable]
+        public BaseBook(int itemID, int pageCount, bool writable)
+            : this(itemID, null, null, pageCount, writable)
+        {
+        }
+
+        [Constructable]
+        public BaseBook(int itemID, string title, string author, int pageCount, bool writable)
+            : base(itemID)
+        {
+            m_Title = title;
+            m_Author = author;
+            m_Writable = writable;
+
+            BookContent content = DefaultContent;
+
+            if (content == null)
+            {
+                m_Pages = new BookPageInfo[pageCount];
+
+                for (int i = 0; i < m_Pages.Length; ++i)
+                    m_Pages[i] = new BookPageInfo();
+            }
+            else
+            {
+                m_Pages = content.Copy();
+            }
+        }
+
+        // Intended for defined books only
+        public BaseBook(int itemID, bool writable)
+            : base(itemID)
+        {
+            m_Writable = writable;
+
+            BookContent content = DefaultContent;
+
+            if (content == null)
+            {
+                m_Pages = new BookPageInfo[0];
+            }
+            else
+            {
+                m_Title = content.Title;
+                m_Author = content.Author;
+                m_Pages = content.Copy();
+            }
+        }
+
+        public virtual BookContent DefaultContent
+        {
+            get
+            {
+                return null;
+            }
+        }
+
+        public void BuildBookFromString(string content)
+        {
+            if (content == null)
+                return;
+
+            const int cpl = 22; //characters per line
+            int pos = 0, nextpos;
+            List<string[]> newpages = new List<string[]>();
+
+            while (newpages.Count < m_Pages.Length && pos < content.Length)
+            {
+                List<string> lines = new List<string>();
+
+                for (int i = 0; i < 8; ++i)
+                {
+                    if (content.Length - pos < cpl)
+                    {
+                        lines.Add(content.Substring(pos));
+                        pos = content.Length;
+                        break;
+                    }
+                    else
+                    {
+                        if ((nextpos = content.LastIndexOfAny(" /|\\.!@#$%^&*()_+=-".ToCharArray(), pos + cpl, cpl)) > 0)
+                        {
+                            lines.Add(content.Substring(pos, (nextpos - pos) + 1));
+                            pos = nextpos + 1;
+                        }
+                        else
+                        {
+                            lines.Add(content.Substring(pos, cpl));
+                            pos += cpl;
+                        }
+                    }
+                }
+
+                newpages.Add(lines.ToArray());
+            }
+
+            for (int i = 0; i < m_Pages.Length; ++i)
+            {
+                if (i < newpages.Count)
+                {
+                    m_Pages[i] = new BookPageInfo(newpages[i]);
+                }
+                else
+                {
+                    m_Pages[i] = new BookPageInfo();
+                }
+            }
+        }
+
+        public BaseBook(Serial serial)
+            : base(serial)
+        {
+        }
+
+        [Flags]
+        private enum SaveFlags
+        {
+            None = 0x00,
+            Title = 0x01,
+            Author = 0x02,
+            Writable = 0x04,
+            Content = 0x08
+        }
+
+        public override void GetContextMenuEntries(Mobile from, List<ContextMenuEntry> list)
+        {
+            base.GetContextMenuEntries(from, list);
+            SetSecureLevelEntry.AddTo(from, this, list);
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            BookContent content = DefaultContent;
+
+            SaveFlags flags = SaveFlags.None;
+
+            if (m_Title != (content == null ? null : content.Title))
+                flags |= SaveFlags.Title;
+
+            if (m_Author != (content == null ? null : content.Author))
+                flags |= SaveFlags.Author;
+
+            if (m_Writable)
+                flags |= SaveFlags.Writable;
+
+            if (content == null || !content.IsMatch(m_Pages))
+                flags |= SaveFlags.Content;
+
+            writer.Write((int)4); // version
+
+            writer.Write((int)m_SecureLevel);
+
+            writer.Write((byte)flags);
+
+            if ((flags & SaveFlags.Title) != 0)
+                writer.Write(m_Title);
+
+            if ((flags & SaveFlags.Author) != 0)
+                writer.Write(m_Author);
+
+            if ((flags & SaveFlags.Content) != 0)
+            {
+                writer.WriteEncodedInt(m_Pages.Length);
+
+                for (int i = 0; i < m_Pages.Length; ++i)
+                    m_Pages[i].Serialize(writer);
+            }
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 4:
+                    {
+                        m_SecureLevel = (SecureLevel)reader.ReadInt();
+                        goto case 3;
+                    }
+                case 3:
+                case 2:
+                    {
+                        BookContent content = DefaultContent;
+
+                        SaveFlags flags = (SaveFlags)reader.ReadByte();
+
+                        if ((flags & SaveFlags.Title) != 0)
+                            m_Title = Utility.Intern(reader.ReadString());
+                        else if (content != null)
+                            m_Title = content.Title;
+
+                        if ((flags & SaveFlags.Author) != 0)
+                            m_Author = reader.ReadString();
+                        else if (content != null)
+                            m_Author = content.Author;
+
+                        m_Writable = (flags & SaveFlags.Writable) != 0;
+
+                        if ((flags & SaveFlags.Content) != 0)
+                        {
+                            m_Pages = new BookPageInfo[reader.ReadEncodedInt()];
+
+                            for (int i = 0; i < m_Pages.Length; ++i)
+                                m_Pages[i] = new BookPageInfo(reader);
+                        }
+                        else
+                        {
+                            if (content != null)
+                                m_Pages = content.Copy();
+                            else
+                                m_Pages = new BookPageInfo[0];
+                        }
+
+                        break;
+                    }
+                case 1:
+                case 0:
+                    {
+                        m_Title = reader.ReadString();
+                        m_Author = reader.ReadString();
+                        m_Writable = reader.ReadBool();
+
+                        if (version == 0 || reader.ReadBool())
+                        {
+                            m_Pages = new BookPageInfo[reader.ReadInt()];
+
+                            for (int i = 0; i < m_Pages.Length; ++i)
+                                m_Pages[i] = new BookPageInfo(reader);
+                        }
+                        else
+                        {
+                            BookContent content = DefaultContent;
+
+                            if (content != null)
+                                m_Pages = content.Copy();
+                            else
+                                m_Pages = new BookPageInfo[0];
+                        }
+
+                        break;
+                    }
+            }
+
+            if (version < 3 && (Weight == 1 || Weight == 2))
+                Weight = -1;
+        }
+
+        public override void AddNameProperty(ObjectPropertyList list)
+        {
+            if (m_Title != null && m_Title.Length > 0)
+                list.Add(m_Title);
+            else
+                base.AddNameProperty(list);
+        }
+		
+        public override void OnSingleClick(Mobile from)
+        {
+            LabelTo(from, "{0} by {1}", m_Title, m_Author);
+            LabelTo(from, "[{0} pages]", m_Pages.Length);
+        }
+		
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (m_Title == null && m_Author == null && m_Writable == true)
+            {
+                Title = "a book";
+                Author = from.Name;
+            }
+
+            from.Send(new BookHeader(from, this));
+            from.Send(new BookPageDetails(this));
+        }
+
+        public string ContentAsString
+        {
+            get
+            {
+                StringBuilder sb = new StringBuilder();
+
+                foreach (BookPageInfo bpi in m_Pages)
+                {
+                    foreach (string line in bpi.Lines)
+                    {
+                        sb.AppendLine(line);
+                    }
+                }
+
+                return sb.ToString();
+            }
+        }
+
+        public string[] ContentAsStringArray
+        {
+            get
+            {
+                List<string> lines = new List<string>();
+
+                foreach (BookPageInfo bpi in m_Pages)
+                {
+                    lines.AddRange(bpi.Lines);
+                }
+
+                return lines.ToArray();
+            }
+        }
+
+        public virtual void ContentChangeEC(NetState state, PacketReader pvSrc)
+        {
+            int page = pvSrc.ReadUInt16();
+            int lineCount = pvSrc.ReadUInt16();
+            int index = page - 1;
+
+            if (index < 0 || index >= m_Pages.Length)
+                return;
+
+            if (lineCount == 0xFFFF)
+            {
+                // send for new page
+                state.Send(new BookPageDetails(this, page, m_Pages[index]));
+            }
+            else if (m_Writable && state.Mobile != null && state.Mobile.InRange(GetWorldLocation(), 1))
+            {
+                // updates after page is moved away from
+                if (lineCount <= 19)
+                {
+                    string[] lines = new string[lineCount];
+
+                    for (int j = 0; j < lineCount; ++j)
+                        if ((lines[j] = pvSrc.ReadUTF8StringSafe()).Length >= 80)
+                            return;
+
+                    m_Pages[index].Lines = lines;
+                }
+                else
+                {
+                    return;
+                }
+            }
+        }
+
+        public static void Initialize()
+        {
+            PacketHandlers.Register(0xD4, 0, true, new OnPacketReceive(HeaderChange));
+            PacketHandlers.Register(0x66, 0, true, new OnPacketReceive(ContentChange));
+            PacketHandlers.Register(0x93, 99, true, new OnPacketReceive(OldHeaderChange));
+        }
+
+        public static void OldHeaderChange(NetState state, PacketReader pvSrc)
+        {
+            Mobile from = state.Mobile;
+            BaseBook book = World.FindItem(pvSrc.ReadInt32()) as BaseBook;
+
+            if (book == null || !book.Writable || !from.InRange(book.GetWorldLocation(), 1) || !book.IsAccessibleTo(from))
+                return;
+
+            pvSrc.Seek(4, SeekOrigin.Current); // Skip flags and page count
+
+            string title = pvSrc.ReadStringSafe(60);
+            string author = pvSrc.ReadStringSafe(30);
+
+            book.Title = Utility.FixHtml(title);
+            book.Author = Utility.FixHtml(author);
+        }
+
+        public static void HeaderChange(NetState state, PacketReader pvSrc)
+        {
+            Mobile from = state.Mobile;
+            BaseBook book = World.FindItem(pvSrc.ReadInt32()) as BaseBook;
+
+            if (book == null || !book.Writable || !from.InRange(book.GetWorldLocation(), 1) || !book.IsAccessibleTo(from))
+                return;
+
+            pvSrc.Seek(4, SeekOrigin.Current); // Skip flags and page count
+
+            int titleLength = pvSrc.ReadUInt16();
+
+            if (titleLength > 60)
+                return;
+
+            string title = pvSrc.ReadUTF8StringSafe(titleLength);
+
+            int authorLength = pvSrc.ReadUInt16();
+
+            if (authorLength > 30)
+                return;
+
+            string author = pvSrc.ReadUTF8StringSafe(authorLength);
+
+            book.Title = Utility.FixHtml(title);
+            book.Author = Utility.FixHtml(author);
+        }
+
+        public static void ContentChange(NetState state, PacketReader pvSrc)
+        {
+            Mobile from = state.Mobile;
+            BaseBook book = World.FindItem(pvSrc.ReadInt32()) as BaseBook;
+
+            if (book == null || !book.Writable || !from.InRange(book.GetWorldLocation(), 1) || !book.IsAccessibleTo(from))
+                return;
+
+            int pageCount = pvSrc.ReadUInt16();
+
+            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;
+                }
+            }
+        }
+
+        #region ISecurable Members
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public SecureLevel Level
+        {
+            get
+            {
+                return m_SecureLevel;
+            }
+            set
+            {
+                m_SecureLevel = value;
+            }
+        }
+        #endregion
+    }
+
+    public sealed class BookPageDetails : Packet
+    {
+        public BookPageDetails(BaseBook 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 BookPageDetails(BaseBook book, int page, BookPageInfo info)
+            : base(0x66)
+        {
+            EnsureCapacity(256);
+
+            m_Stream.Write((int)book.Serial);
+            m_Stream.Write((ushort)0x1);
+
+            m_Stream.Write((ushort)page);
+            m_Stream.Write((ushort)info.Lines.Length);
+
+            for (int i = 0; i < info.Lines.Length; ++i)
+            {
+                byte[] buffer = Utility.UTF8.GetBytes(info.Lines[i]);
+
+                m_Stream.Write(buffer, 0, buffer.Length);
+                m_Stream.Write((byte)0);
+            }
+        }
+    }
+
+    public sealed class BookHeader : Packet
+    {
+        public BookHeader(Mobile from, BaseBook 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
+        }
+    }
+}