public SpChat(string message, int sessionId, string characterName, ChatType chatType)
 {
     _message = message;
     _sessionId = sessionId;
     _characterName = characterName;
     _chatType = chatType;
 }

        public override EventEat OnSay3(Entity player, ChatType type, string name, ref string message)
        {
            string[] splitmsg = message.ToLower().Split(' ');

            foreach (string word in splitmsg)
            {
                if (BadWordsList.Contains(word))
                {
                    if (!player.HasField("warnsbadwords")) player.SetField("warnsbadwords", new Parameter(0));
                    if (player.GetField<int>("warnsbadwords") >= 2)
                    {
                        Utilities.RawSayAll("^1BAD^2WORDS^3: " + player.Name + " got kicked for ^1Bad^2words");
                        Utilities.ExecuteCommand("dropclient " + player.EntRef + " \"" + "^3Bad ^2words ^1DETECTED" + "\"");
                        return EventEat.EatGame;
                    }
                    else
                    {
                        Utilities.RawSayTo(player, "Don't use any ^1offensive ^2language");
                        player.SetField("warnsbadwords",player.GetField<int>("warnsbadwords") + 1);
                        return EventEat.EatGame;
                    }
                }
            }
            return EventEat.EatNone;
        }

 /// <summary>
 /// Creates a ConsoleMessage from a native instance's attributes
 /// </summary>
 internal ConsoleMessage(IntPtr pointer)
     : base(pointer)
 {
     Color   = new Color(pointer);
     Type    = (ChatType)       Functions.vp_int(pointer, IntAttributes.ChatType);
     Effect  = (ChatEffect) Functions.vp_int(pointer, IntAttributes.ChatType);
 }

 public SpChatMessage(Player player, string message, ChatType type, bool sysmsg = false)
 {
     Player = player;
     Message = message;
     Type = type;
     IsSystemMessage = sysmsg;
 }

 public ChatMessage(Character sender, ChatType type, int dest, string message)
 {
     this.Sender = sender;
     this.Type = type;
     this.Destination = dest;
     this.Message = message;
 }

        public void SendMessage(ChatType type, string message)
        {
            if (type == ChatType.Private)
                return;

            SendMessage(type, new Character(), message);
        }

 protected ChatModel(string id, string name, ChatType chatType, IProtocolManager networkManager)
 {
     _ID = id;
     _Name = name;
     _ChatType = chatType;
     _ProtocolManager = networkManager;
 }

        public void ChatOut(string chat, ChatType type, int channel)
        {
            if (!loggedIn) return;

            client.Self.Chat(chat, channel, type);
            OnChatSent(new ChatSentEventArgs(chat, type, channel));
        }

 public override void Read()
 {
     Type = (ChatType)ReadC();
     RecvName = ReadSN();
     ReadB(7);
     Message = ReadS();
 }

 public BaseChat(ChatType chatType, string message)
 {
     packet.Type(1006);
     packet.WriteShort((short)chatType);
     packet.WriteString(message);
     packet.WriteByte(0);
 }

        public frmSpelling(METAboltInstance instance, string sentence, string[] swords, ChatType type)
        {
            InitializeComponent();

            this.instance = instance;

            afffile = this.instance.AffFile;   // "en_GB.aff";
            dicfile = this.instance.DictionaryFile;   // "en_GB.dic";

            string[] idic = dicfile.Split('.');
            dic = dir + idic[0];

            if (!System.IO.File.Exists(dic + ".csv"))
            {
                System.IO.File.Create(dic + ".csv");
            }

            try
            {
                hunspell.Load(dir + afffile, dir + dicfile);   //("en_us.aff", "en_us.dic");
                ReadWords();
            }
            catch
            {
                //string exp = ex.Message;
            }

            //words = sentence;
            richTextBox1.Text = sentence;
            this.swords = swords;
            this.ctype = type;

            ischat = true;
        }

 /// <summary>
 /// Initializes a new instance of the ChatPacket class.
 /// This overload should be used by the server because
 /// the client needs to know who sent the message.
 /// </summary>
 /// <param name="chat">The text of the chat message.</param>
 /// <param name="sender">The player who sent the chat message.</param>
 /// <param name="chatType">The type of chat.</param>
 public ChatPacket(string chat, string sender, ChatType chatType)
     : base()
 {
     this.Chat = chat;
     this.Sender = sender;
     this.ChatType = chatType;
 }

        public static ServerMessage Compose(uint ActorId, string MessageText, int EmotionId, ChatType ChatType)
        {
            StringBuilder TextBuilder = new StringBuilder();
            Dictionary<int, string> LinkRefs = new Dictionary<int, string>();
            string[] Bits = MessageText.Split(' ');

            int i = 0;
            int j = 0;

            foreach (string Bit in Bits)
            {
                if (j > 0)
                {
                    TextBuilder.Append(' ');
                }

                if (Bit.StartsWith("http://"))
                {
                    LinkRefs.Add(i, Bit);
                    TextBuilder.Append("{" + i++ + "}");
                }
                else if (Bit.StartsWith("www."))
                {
                    LinkRefs.Add(i, Bit);
                    TextBuilder.Append("{" + i++ + "}");
                }
                else
                {
                    TextBuilder.Append(Bit);
                }

                j++;
            }

            ServerMessage Message = new ServerMessage(ChatType == ChatType.Say ? OpcodesOut.ROOM_CHAT_SAY : (ChatType ==
                ChatType.Whisper ? OpcodesOut.ROOM_CHAT_WHISPER : OpcodesOut.ROOM_CHAT_SHOUT));
            Message.AppendUInt32(ActorId);
            Message.AppendStringWithBreak(TextBuilder.ToString());
            Message.AppendInt32(EmotionId);
            Message.AppendInt32(LinkRefs.Count);

            foreach (KeyValuePair<int, string> LinkedRef in LinkRefs)
            {
                string Url = LinkedRef.Value;

                if (!Url.StartsWith("http://"))
                {
                    Url = "http://" + Url;
                }

                Message.AppendStringWithBreak("/link_to.php?url=" + HttpUtility.UrlEncode(Url) + "&hash=xx");
                Message.AppendStringWithBreak(LinkedRef.Value);
                Message.AppendBoolean(false); // Trusted URL (instaopen)
            }

            Message.AppendInt32(0); // No idea
            Message.AppendBoolean(true);
            return Message;
        }

 static void Self_OnChat(string message, ChatAudibleLevel audible, ChatType type, ChatSourceType sourceType, string fromName, UUID id, UUID ownerid, Vector3 position)
 {
     if (fromName != _Client.Self.Name &&  type == ChatType.Normal && audible == ChatAudibleLevel.Fully)
     {
         string str = "<" + fromName + "> " + message;
         _IRC.SendMessage(_AutoJoinChannel, str);
         Console.WriteLine("[SL->IRC] " + str);
     }
 }

 public ChatViewAddedEventArgs(ChatModel chatModel, string chatId,
                               ChatType chatType, int chatPosition,
                               Type protocolManagerType)
 {
     ChatModel = chatModel;
     ChatID = chatId;
     ChatType = chatType;
     ChatPosition = chatPosition;
     ProtocolManagerType = protocolManagerType;
 }

 public ChatEventArgs(string message, ChatAudibleLevel audible, ChatType type, ChatSourceType sourceType, string fromName, LLUUID id, LLUUID ownerid, LLVector3 position)
 {
     this.message = message;
     this.audible = audible;
     this.type = type;
     this.sourceType = sourceType;
     this.fromName = fromName;
     this.id = id;
     this.ownerid = ownerid;
     this.position = position;
 }

        public void ChatToDebug(ChatType type, Character sender, string message, GameReader packet, GameData gameData, ExtensionHandler extensions)
        {
            if (type == ChatType.Announcement)
                sender.Name = "";
            Debug.Information(type.ToString() + ":" + sender.Name + ": " + message);

            if (type == ChatType.Private && sender.Name == "Reporter")
            {
                gameData.commands.SendMessage(ChatType.Private, sender, "ECHO: " + message);
            }
        }

        public static void CreateChatMessage(ChatType type, string message, ServerToClientMessage wm)
        {
            if (wm.Sender == null)
                throw (new Exception("wm.Sender can't be NULL on outgoing messages."));

            wm.MessageType = MessageType.S2C_ChatMessage;
            wm.Code = (int)type;
            wm.DeliveryMethod = NetDeliveryMethod.ReliableOrdered;
            wm.DeliveryChannel = 0;
            wm.Data = message;
        }

 protected ChatModel(string id, string name, ChatType chatType, IProtocolManager networkManager)
 {
     _ID = id;
     _Name = name;
     _ChatType = chatType;
     _ProtocolManager = networkManager;
     Position = -1;
     if (ProtocolManager == null) {
         InitMessageBuffer(MessageBufferPersistencyType.Volatile);
     }
 }

 public List<Message> GetChats(ChatType chatType)
 {
     try
     {
         return messages.Where(x => x.ChatType == chatType).ToList();
     }
     catch (Exception errormessage)
     {
         File.AppendAllText(path, "Message: " + errormessage.Message + "InnerException: " + errormessage.InnerException + "Date and Time: " + DateTime.Now);
         throw new FaultException("Error while trying to retrieve messages");
     }
 }