Overwrite

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

Scripts/Items/Functional/BulletinBoards.cs

@@ -0,0 +1,716 @@
+using System;
+using System.Collections.Generic;
+using Server.Network;
+
+namespace Server.Items
+{
+    public struct BulletinEquip
+    {
+        public int itemID;
+        public int hue;
+        public BulletinEquip(int itemID, int hue)
+        {
+            this.itemID = itemID;
+            this.hue = hue;
+        }
+    }
+
+    [Flipable(0x1E5E, 0x1E5F)]
+    public class BulletinBoard : BaseBulletinBoard
+    {
+        [Constructable]
+        public BulletinBoard()
+            : base(0x1E5E)
+        {
+        }
+
+        public BulletinBoard(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();
+        }
+    }
+
+    public abstract class BaseBulletinBoard : Item
+    {
+        // Threads will be removed six hours after the last post was made
+        private static readonly TimeSpan ThreadDeletionTime = TimeSpan.FromHours(6.0);
+        // A player may only create a thread once every two minutes
+        private static readonly TimeSpan ThreadCreateTime = TimeSpan.FromMinutes(2.0);
+        // A player may only reply once every thirty seconds
+        private static readonly TimeSpan ThreadReplyTime = TimeSpan.FromSeconds(30.0);
+        private string m_BoardName;
+        public BaseBulletinBoard(int itemID)
+            : base(itemID)
+        {
+            this.m_BoardName = "bulletin board";
+            this.Movable = false;
+        }
+
+        public BaseBulletinBoard(Serial serial)
+            : base(serial)
+        {
+        }
+
+        [CommandProperty(AccessLevel.GameMaster)]
+        public string BoardName
+        {
+            get
+            {
+                return this.m_BoardName;
+            }
+            set
+            {
+                this.m_BoardName = value;
+            }
+        }
+        public static bool CheckTime(DateTime time, TimeSpan range)
+        {
+            return (time + range) < DateTime.UtcNow;
+        }
+
+        public static string FormatTS(TimeSpan ts)
+        {
+            int totalSeconds = (int)ts.TotalSeconds;
+            int seconds = totalSeconds % 60;
+            int minutes = totalSeconds / 60;
+
+            if (minutes != 0 && seconds != 0)
+                return String.Format("{0} minute{1} and {2} second{3}", minutes, minutes == 1 ? "" : "s", seconds, seconds == 1 ? "" : "s");
+            else if (minutes != 0)
+                return String.Format("{0} minute{1}", minutes, minutes == 1 ? "" : "s");
+            else
+                return String.Format("{0} second{1}", seconds, seconds == 1 ? "" : "s");
+        }
+
+        public static void Initialize()
+        {
+            PacketHandlers.Register(0x71, 0, true, new OnPacketReceive(BBClientRequest));
+        }
+
+        public static void BBClientRequest(NetState state, PacketReader pvSrc)
+        {
+            Mobile from = state.Mobile;
+
+            int packetID = pvSrc.ReadByte();
+            BaseBulletinBoard board = World.FindItem(pvSrc.ReadInt32()) as BaseBulletinBoard;
+
+            if (board == null || !board.CheckRange(from))
+                return;
+
+            switch ( packetID )
+            {
+                case 3:
+                    BBRequestContent(from, board, pvSrc);
+                    break;
+                case 4:
+                    BBRequestHeader(from, board, pvSrc);
+                    break;
+                case 5:
+                    BBPostMessage(from, board, pvSrc);
+                    break;
+                case 6:
+                    BBRemoveMessage(from, board, pvSrc);
+                    break;
+            }
+        }
+
+        public static void BBRequestContent(Mobile from, BaseBulletinBoard board, PacketReader pvSrc)
+        {
+            BulletinMessage msg = World.FindItem(pvSrc.ReadInt32()) as BulletinMessage;
+
+            if (msg == null || msg.Parent != board)
+                return;
+
+            from.Send(new BBMessageContent(board, msg));
+        }
+
+        public static void BBRequestHeader(Mobile from, BaseBulletinBoard board, PacketReader pvSrc)
+        {
+            BulletinMessage msg = World.FindItem(pvSrc.ReadInt32()) as BulletinMessage;
+
+            if (msg == null || msg.Parent != board)
+                return;
+
+            from.Send(new BBMessageHeader(board, msg));
+        }
+
+        public static void BBPostMessage(Mobile from, BaseBulletinBoard board, PacketReader pvSrc)
+        {
+            BulletinMessage thread = World.FindItem(pvSrc.ReadInt32()) as BulletinMessage;
+
+            if (thread != null && thread.Parent != board)
+                thread = null;
+
+            int breakout = 0;
+
+            while (thread != null && thread.Thread != null && breakout++ < 10)
+                thread = thread.Thread;
+
+            DateTime lastPostTime = DateTime.MinValue;
+
+            if (board.GetLastPostTime(from, (thread == null), ref lastPostTime))
+            {
+                if (!CheckTime(lastPostTime, (thread == null ? ThreadCreateTime : ThreadReplyTime)))
+                {
+                    if (thread == null)
+                        from.SendMessage("You must wait {0} before creating a new thread.", FormatTS(ThreadCreateTime));
+                    else
+                        from.SendMessage("You must wait {0} before replying to another thread.", FormatTS(ThreadReplyTime));
+
+                    return;
+                }
+            }
+
+            string subject = pvSrc.ReadUTF8StringSafe(pvSrc.ReadByte());
+
+            if (subject.Length == 0)
+                return;
+
+            string[] lines = new string[pvSrc.ReadByte()];
+
+            if (lines.Length == 0)
+                return;
+
+            for (int i = 0; i < lines.Length; ++i)
+                lines[i] = pvSrc.ReadUTF8StringSafe(pvSrc.ReadByte());
+
+            board.PostMessage(from, thread, subject, lines);
+        }
+
+        public static void BBRemoveMessage(Mobile from, BaseBulletinBoard board, PacketReader pvSrc)
+        {
+            BulletinMessage msg = World.FindItem(pvSrc.ReadInt32()) as BulletinMessage;
+
+            if (msg == null || msg.Parent != board)
+                return;
+
+            if (from.AccessLevel < AccessLevel.GameMaster && msg.Poster != from)
+                return;
+
+            msg.Delete();
+        }
+
+        public virtual void Cleanup()
+        {
+            List<Item> items = this.Items;
+
+            for (int i = items.Count - 1; i >= 0; --i)
+            {
+                if (i >= items.Count)
+                    continue;
+
+                BulletinMessage msg = items[i] as BulletinMessage;
+
+                if (msg == null)
+                    continue;
+
+                if (msg.Thread == null && CheckTime(msg.LastPostTime, ThreadDeletionTime))
+                {
+                    msg.Delete();
+                    this.RecurseDelete(msg); // A root-level thread has expired
+                }
+            }
+        }
+
+        public virtual bool GetLastPostTime(Mobile poster, bool onlyCheckRoot, ref DateTime lastPostTime)
+        {
+            List<Item> items = this.Items;
+            bool wasSet = false;
+
+            for (int i = 0; i < items.Count; ++i)
+            {
+                BulletinMessage msg = items[i] as BulletinMessage;
+
+                if (msg == null || msg.Poster != poster)
+                    continue;
+
+                if (onlyCheckRoot && msg.Thread != null)
+                    continue;
+
+                if (msg.Time > lastPostTime)
+                {
+                    wasSet = true;
+                    lastPostTime = msg.Time;
+                }
+            }
+
+            return wasSet;
+        }
+
+        public override void OnDoubleClick(Mobile from)
+        {
+            if (this.CheckRange(from))
+            {
+                this.Cleanup();
+
+                NetState state = from.NetState;
+
+                state.Send(new BBDisplayBoard(this));
+                if (state.ContainerGridLines)
+                    state.Send(new ContainerContent6017(from, this));
+                else
+                    state.Send(new ContainerContent(from, this));
+            }
+            else
+            {
+                from.LocalOverheadMessage(MessageType.Regular, 0x3B2, 1019045); // I can't reach that.
+            }
+        }
+
+        public virtual bool CheckRange(Mobile from)
+        {
+            if (from.AccessLevel >= AccessLevel.GameMaster)
+                return true;
+
+            return (from.Map == this.Map && from.InRange(this.GetWorldLocation(), 2));
+        }
+
+        public void PostMessage(Mobile from, BulletinMessage thread, string subject, string[] lines)
+        {
+            if (thread != null)
+                thread.LastPostTime = DateTime.UtcNow;
+
+            this.AddItem(new BulletinMessage(from, thread, subject, lines));
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)0); // version
+
+            writer.Write((string)this.m_BoardName);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 0:
+                    {
+                        this.m_BoardName = reader.ReadString();
+                        break;
+                    }
+            }
+        }
+
+        private void RecurseDelete(BulletinMessage msg)
+        {
+            List<Item> found = new List<Item>();
+            List<Item> items = this.Items;
+
+            for (int i = items.Count - 1; i >= 0; --i)
+            {
+                if (i >= items.Count)
+                    continue;
+
+                BulletinMessage check = items[i] as BulletinMessage;
+
+                if (check == null)
+                    continue;
+
+                if (check.Thread == msg)
+                {
+                    check.Delete();
+                    found.Add(check);
+                }
+            }
+
+            for (int i = 0; i < found.Count; ++i)
+                this.RecurseDelete((BulletinMessage)found[i]);
+        }
+    }
+
+    public class BulletinMessage : Item
+    {
+        private Mobile m_Poster;
+        private string m_Subject;
+        private DateTime m_Time, m_LastPostTime;
+        private BulletinMessage m_Thread;
+        private string m_PostedName;
+        private int m_PostedBody;
+        private int m_PostedHue;
+        private BulletinEquip[] m_PostedEquip;
+        private string[] m_Lines;
+        public BulletinMessage(Mobile poster, BulletinMessage thread, string subject, string[] lines)
+            : base(0xEB0)
+        {
+            this.Movable = false;
+
+            this.m_Poster = poster;
+            this.m_Subject = subject;
+            this.m_Time = DateTime.UtcNow;
+            this.m_LastPostTime = this.m_Time;
+            this.m_Thread = thread;
+            this.m_PostedName = this.m_Poster.Name;
+            this.m_PostedBody = this.m_Poster.Body;
+            this.m_PostedHue = this.m_Poster.Hue;
+            this.m_Lines = lines;
+
+            List<BulletinEquip> list = new List<BulletinEquip>();
+
+            for (int i = 0; i < poster.Items.Count; ++i)
+            {
+                Item item = poster.Items[i];
+
+                if (item.Layer >= Layer.OneHanded && item.Layer <= Layer.Mount)
+                    list.Add(new BulletinEquip(item.ItemID, item.Hue));
+            }
+
+            this.m_PostedEquip = list.ToArray();
+        }
+
+        public BulletinMessage(Serial serial)
+            : base(serial)
+        {
+        }
+
+        public Mobile Poster
+        {
+            get
+            {
+                return this.m_Poster;
+            }
+        }
+        public BulletinMessage Thread
+        {
+            get
+            {
+                return this.m_Thread;
+            }
+        }
+        public string Subject
+        {
+            get
+            {
+                return this.m_Subject;
+            }
+        }
+        public DateTime Time
+        {
+            get
+            {
+                return this.m_Time;
+            }
+        }
+        public DateTime LastPostTime
+        {
+            get
+            {
+                return this.m_LastPostTime;
+            }
+            set
+            {
+                this.m_LastPostTime = value;
+            }
+        }
+        public string PostedName
+        {
+            get
+            {
+                return this.m_PostedName;
+            }
+        }
+        public int PostedBody
+        {
+            get
+            {
+                return this.m_PostedBody;
+            }
+        }
+        public int PostedHue
+        {
+            get
+            {
+                return this.m_PostedHue;
+            }
+        }
+        public BulletinEquip[] PostedEquip
+        {
+            get
+            {
+                return this.m_PostedEquip;
+            }
+        }
+        public string[] Lines
+        {
+            get
+            {
+                return this.m_Lines;
+            }
+        }
+        public string GetTimeAsString()
+        {
+            return this.m_Time.ToString("MMM dd, yyyy");
+        }
+
+        public override bool CheckTarget(Mobile from, Server.Targeting.Target targ, object targeted)
+        {
+            return false;
+        }
+
+        public override bool IsAccessibleTo(Mobile check)
+        {
+            return false;
+        }
+
+        public override void Serialize(GenericWriter writer)
+        {
+            base.Serialize(writer);
+
+            writer.Write((int)1); // version
+
+            writer.Write((Mobile)this.m_Poster);
+            writer.Write((string)this.m_Subject);
+            writer.Write((DateTime)this.m_Time);
+            writer.Write((DateTime)this.m_LastPostTime);
+            writer.Write((bool)(this.m_Thread != null));
+            writer.Write((Item)this.m_Thread);
+            writer.Write((string)this.m_PostedName);
+            writer.Write((int)this.m_PostedBody);
+            writer.Write((int)this.m_PostedHue);
+
+            writer.Write((int)this.m_PostedEquip.Length);
+
+            for (int i = 0; i < this.m_PostedEquip.Length; ++i)
+            {
+                writer.Write((int)this.m_PostedEquip[i].itemID);
+                writer.Write((int)this.m_PostedEquip[i].hue);
+            }
+
+            writer.Write((int)this.m_Lines.Length);
+
+            for (int i = 0; i < this.m_Lines.Length; ++i)
+                writer.Write((string)this.m_Lines[i]);
+        }
+
+        public override void Deserialize(GenericReader reader)
+        {
+            base.Deserialize(reader);
+
+            int version = reader.ReadInt();
+
+            switch ( version )
+            {
+                case 1:
+                case 0:
+                    {
+                        this.m_Poster = reader.ReadMobile();
+                        this.m_Subject = reader.ReadString();
+                        this.m_Time = reader.ReadDateTime();
+                        this.m_LastPostTime = reader.ReadDateTime();
+                        bool hasThread = reader.ReadBool();
+                        this.m_Thread = reader.ReadItem() as BulletinMessage;
+                        this.m_PostedName = reader.ReadString();
+                        this.m_PostedBody = reader.ReadInt();
+                        this.m_PostedHue = reader.ReadInt();
+
+                        this.m_PostedEquip = new BulletinEquip[reader.ReadInt()];
+
+                        for (int i = 0; i < this.m_PostedEquip.Length; ++i)
+                        {
+                            this.m_PostedEquip[i].itemID = reader.ReadInt();
+                            this.m_PostedEquip[i].hue = reader.ReadInt();
+                        }
+
+                        this.m_Lines = new string[reader.ReadInt()];
+
+                        for (int i = 0; i < this.m_Lines.Length; ++i)
+                            this.m_Lines[i] = reader.ReadString();
+
+                        if (hasThread && this.m_Thread == null)
+                            this.Delete();
+
+                        if (version == 0)
+                            ValidationQueue<BulletinMessage>.Add(this);
+
+                        break;
+                    }
+            }
+        }
+
+        public void Validate()
+        {
+            if (!(this.Parent is BulletinBoard && ((BulletinBoard)this.Parent).Items.Contains(this)))
+                this.Delete();
+        }
+    }
+
+    public class BBDisplayBoard : Packet
+    {
+        public BBDisplayBoard(BaseBulletinBoard board)
+            : base(0x71)
+        {
+            string name = board.BoardName;
+
+            if (name == null)
+                name = "";
+
+            this.EnsureCapacity(38);
+
+            byte[] buffer = Utility.UTF8.GetBytes(name);
+
+            this.m_Stream.Write((byte)0x00); // PacketID
+            this.m_Stream.Write((int)board.Serial); // Bulletin board serial
+
+            // Bulletin board name
+            if (buffer.Length >= 29)
+            {
+                this.m_Stream.Write(buffer, 0, 29);
+                this.m_Stream.Write((byte)0);
+            }
+            else
+            {
+                this.m_Stream.Write(buffer, 0, buffer.Length);
+                this.m_Stream.Fill(30 - buffer.Length);
+            }
+        }
+    }
+
+    public class BBMessageHeader : Packet
+    {
+        public BBMessageHeader(BaseBulletinBoard board, BulletinMessage msg)
+            : base(0x71)
+        {
+            string poster = this.SafeString(msg.PostedName);
+            string subject = this.SafeString(msg.Subject);
+            string time = this.SafeString(msg.GetTimeAsString());
+
+            this.EnsureCapacity(22 + poster.Length + subject.Length + time.Length);
+
+            this.m_Stream.Write((byte)0x01); // PacketID
+            this.m_Stream.Write((int)board.Serial); // Bulletin board serial
+            this.m_Stream.Write((int)msg.Serial); // Message serial
+
+            BulletinMessage thread = msg.Thread;
+
+            if (thread == null)
+                this.m_Stream.Write((int)0); // Thread serial--root
+            else
+                this.m_Stream.Write((int)thread.Serial); // Thread serial--parent
+
+            this.WriteString(poster);
+            this.WriteString(subject);
+            this.WriteString(time);
+        }
+
+        public void WriteString(string v)
+        {
+            byte[] buffer = Utility.UTF8.GetBytes(v);
+            int len = buffer.Length + 1;
+
+            if (len > 255)
+                len = 255;
+
+            this.m_Stream.Write((byte)len);
+            this.m_Stream.Write(buffer, 0, len - 1);
+            this.m_Stream.Write((byte)0);
+        }
+
+        public string SafeString(string v)
+        {
+            if (v == null)
+                return String.Empty;
+
+            return v;
+        }
+    }
+
+    public class BBMessageContent : Packet
+    {
+        public BBMessageContent(BaseBulletinBoard board, BulletinMessage msg)
+            : base(0x71)
+        {
+            string poster = this.SafeString(msg.PostedName);
+            string subject = this.SafeString(msg.Subject);
+            string time = this.SafeString(msg.GetTimeAsString());
+
+            this.EnsureCapacity(22 + poster.Length + subject.Length + time.Length);
+
+            this.m_Stream.Write((byte)0x02); // PacketID
+            this.m_Stream.Write((int)board.Serial); // Bulletin board serial
+            this.m_Stream.Write((int)msg.Serial); // Message serial
+
+            this.WriteString(poster);
+            this.WriteString(subject);
+            this.WriteString(time);
+
+            this.m_Stream.Write((short)msg.PostedBody);
+            this.m_Stream.Write((short)msg.PostedHue);
+
+            int len = msg.PostedEquip.Length;
+
+            if (len > 255)
+                len = 255;
+
+            this.m_Stream.Write((byte)len);
+
+            for (int i = 0; i < len; ++i)
+            {
+                BulletinEquip eq = msg.PostedEquip[i];
+
+                this.m_Stream.Write((short)eq.itemID);
+                this.m_Stream.Write((short)eq.hue);
+            }
+
+            len = msg.Lines.Length;
+
+            if (len > 255)
+                len = 255;
+
+            this.m_Stream.Write((byte)len);
+
+            for (int i = 0; i < len; ++i)
+                this.WriteString(msg.Lines[i], true);
+        }
+
+        public void WriteString(string v)
+        {
+            this.WriteString(v, false);
+        }
+
+        public void WriteString(string v, bool padding)
+        {
+            byte[] buffer = Utility.UTF8.GetBytes(v);
+            int tail = padding ? 2 : 1;
+            int len = buffer.Length + tail;
+
+            if (len > 255)
+                len = 255;
+
+            this.m_Stream.Write((byte)len);
+            this.m_Stream.Write(buffer, 0, len - tail);
+
+            if (padding)
+                this.m_Stream.Write((short)0); // padding compensates for a client bug
+            else
+                this.m_Stream.Write((byte)0);
+        }
+
+        public string SafeString(string v)
+        {
+            if (v == null)
+                return String.Empty;
+
+            return v;
+        }
+    }
+}