private IEnumerator SendChat(float delay, ChatMessageBase message)
        {
            yield return(new WaitForSeconds(delay));

            Chat.SendBroadcastChat(message);
            yield break;
        }
Esempio n. 2
0
 /// <summary>
 /// Add common parameters before calling a procedure
 /// </summary>
 /// <param name="cmd">command object, where parameters will be added</param>
 /// <param name="chatMessageObject"></param>
 private void AddCommonParams(SqlCommand cmd, ChatMessageBase chatMessageObject)
 {
     AddParameter(cmd, pGuid(ChatMessageBase.Property_SenderId, chatMessageObject.SenderId));
     AddParameter(cmd, pGuid(ChatMessageBase.Property_RecieverId, chatMessageObject.RecieverId));
     AddParameter(cmd, pNVarChar(ChatMessageBase.Property_Message, chatMessageObject.Message));
     AddParameter(cmd, pDateTime(ChatMessageBase.Property_SendDate, chatMessageObject.SendDate));
     AddParameter(cmd, pDateTime(ChatMessageBase.Property_ReadDate, chatMessageObject.ReadDate));
 }
Esempio n. 3
0
        /// <summary>
        /// Sends a ChatMessage directly to a connection. Checkout RoR2.Chat for possible chatmessage types.
        /// </summary>
        /// <param name="message">The message to send</param>
        /// <param name="connection">The network connection to send to.</param>
        public static void SendDirectMessage(ChatMessageBase message, NetworkConnection?connection)
        {
            NetworkWriter writer = new NetworkWriter();

            writer.StartMessage((short)59);
            writer.Write(message.GetTypeIndex());
            writer.Write((MessageBase)message);
            writer.FinishMessage();
            connection.SendWriter(writer, RoR2.Networking.QosChannelIndex.chat.intVal);
        }
Esempio n. 4
0
        public static void SendPM(NetworkConnection conn, ChatMessageBase message)
        {
            NetworkWriter networkWriter = new NetworkWriter();

            networkWriter.StartMessage(59);
            networkWriter.Write(message.GetTypeIndex());
            networkWriter.Write(message);
            networkWriter.FinishMessage();
            conn.SendWriter(networkWriter, QosChannelIndex.chat.intVal);
        }
Esempio n. 5
0
        /// <summary>
        /// Fills ChatMessage object
        /// </summary>
        /// <param name="chatMessageObject">The object to be filled</param>
        /// <param name="reader">The reader to use to fill a single object</param>
        /// <param name="start">The ordinal position from which to start reading the reader</param>
        protected void FillObject(ChatMessageBase chatMessageObject, SqlDataReader reader, int start)
        {
            chatMessageObject.Id         = reader.GetInt32(start + 0);
            chatMessageObject.SenderId   = reader.GetGuid(start + 1);
            chatMessageObject.RecieverId = reader.GetGuid(start + 2);
            chatMessageObject.Message    = reader.GetString(start + 3);
            chatMessageObject.SendDate   = reader.GetDateTime(start + 4);
            if (!reader.IsDBNull(5))
            {
                chatMessageObject.ReadDate = reader.GetDateTime(start + 5);
            }
            FillBaseObject(chatMessageObject, reader, (start + 6));


            chatMessageObject.RowState = BaseBusinessEntity.RowStateEnum.NormalRow;
        }
Esempio n. 6
0
        /// <summary>
        /// Updates ChatMessage
        /// </summary>
        /// <param name="chatMessageObject">Object to be updated</param>
        /// <returns>Number of rows affected</returns>
        public long Update(ChatMessageBase chatMessageObject)
        {
            try
            {
                SqlCommand cmd = GetSPCommand(UPDATECHATMESSAGE);

                AddParameter(cmd, pInt32(ChatMessageBase.Property_Id, chatMessageObject.Id));
                AddCommonParams(cmd, chatMessageObject);

                long result = UpdateRecord(cmd);
                if (result > 0)
                {
                    chatMessageObject.RowState = BaseBusinessEntity.RowStateEnum.NormalRow;
                }
                return(result);
            }
            catch (SqlException x)
            {
                throw new ObjectUpdateException(chatMessageObject, x);
            }
        }
Esempio n. 7
0
        /// <summary>
        /// Inserts ChatMessage
        /// </summary>
        /// <param name="chatMessageObject">Object to be inserted</param>
        /// <returns>Number of rows affected</returns>
        public long Insert(ChatMessageBase chatMessageObject)
        {
            try
            {
                SqlCommand cmd = GetSPCommand(INSERTCHATMESSAGE);

                AddParameter(cmd, pInt32Out(ChatMessageBase.Property_Id));
                AddCommonParams(cmd, chatMessageObject);

                long result = InsertRecord(cmd);
                if (result > 0)
                {
                    chatMessageObject.RowState = BaseBusinessEntity.RowStateEnum.NormalRow;
                    chatMessageObject.Id       = (Int32)GetOutParameter(cmd, ChatMessageBase.Property_Id);
                }
                return(result);
            }
            catch (SqlException x)
            {
                throw new ObjectInsertException(chatMessageObject, x);
            }
        }
Esempio n. 8
0
        private void Chat_SendBroadcastChat_ChatMessageBase(On.RoR2.Chat.orig_SendBroadcastChat_ChatMessageBase orig, ChatMessageBase message)
        {
            if (cfgEditLanguage.Value && message is Chat.SubjectFormatChatMessage subjectMsg)
            {
                if (subjectMsg.baseToken == "SHRINE_BOSS_USE_MESSAGE")
                {
                    subjectMsg.baseToken   = "QOL_SHRINE_BOSS_USE_MESSAGE";
                    subjectMsg.paramTokens = new string[] { $"{GetShrineCount()}" };
                }
            }

            // x? command
            bool isAskingForShrineAmount = false;

            if (cfgAddChatMessage.Value && message is Chat.UserChatMessage chatMsg)
            {
                switch (chatMsg.text)
                {
                case "x?":
                case "x ?":
                    isAskingForShrineAmount = true;
                    break;
                }
            }
            orig(message);
            if (isAskingForShrineAmount)
            {
                SayMountainShrineAmount();
            }
        }
Esempio n. 9
0
 private void OnChatMessagesUpdateNotification(ChatUpdateNotification notification)
 {
     ChatMessages.AddRange(
         notification.Messages.Select(k => ChatMessageBase.Create(k)));
 }
Esempio n. 10
0
 /// <summary>
 /// Fills ChatMessage object
 /// </summary>
 /// <param name="chatMessageObject">The object to be filled</param>
 /// <param name="reader">The reader to use to fill a single object</param>
 protected void FillObject(ChatMessageBase chatMessageObject, SqlDataReader reader)
 {
     FillObject(chatMessageObject, reader, 0);
 }
Esempio n. 11
0
 private void Chat_AddMessage_ChatMessageBase(On.RoR2.Chat.orig_AddMessage_ChatMessageBase orig, ChatMessageBase message)
 {
     orig(message);
 }