void Client_WhisperReceived(object sender, ChatMessageEventArgs e) { if (__whisperReceived != null) { __whisperReceived.Call(_host.ClientHost, ConvObj(e)); } }
public void Send(string text) { if (IsConnected) { BncsPacket pck = new BncsPacket(BncsPacketId.ChatCommand, _storage.Acquire()); pck.InsertCString(text, Encoding.UTF8); pck.SendAsync(_connection); if (text.StartsWith(EMOTE_1, StringComparison.OrdinalIgnoreCase) || text.StartsWith(EMOTE_2, StringComparison.OrdinalIgnoreCase)) { // do nothing, but we need this case first so that command sent doesn't fire for emotes. } else if (text.StartsWith(COMMAND_START, StringComparison.Ordinal)) { //OnCommandSent(new InformationEventArgs(text)); } else { ChatMessageEventArgs <UserFlags> cme = new ChatMessageEventArgs <UserFlags>(ChatEventType.Talk, UserFlags.None, "(me)", text); _channel.HandleChatMessageEvent(cme); //ChatMessageEventArgs<UserFlags> cme = new ChatMessageEventArgs<UserFlags>(ChatEventType.Talk, UserFlags.None, this._uniqueUN, text); OnMessageSent(text); } } }
private static void Chat_OnMessageReceived(ChatMessageEventArgs e) { if (!useAggressiveParser) { if (e.User == "Scottybot" && e.Message.Contains("code:") || e.Message.Contains("Code:") || e.Message.Contains(":")) { var code = e.Message.Substring(e.Message.IndexOf(':') + 1).Trim(); shouldAddCode(code, e.User); } } else { if (isWhitelistedUser(e.User)) { var words = GetPotentialCodesFromMessage(e.Message); foreach (var word in words) { shouldAddCode(word, e.User); blacklistedWords.Add(word); SaveSettings(); } shouldUpdateActiveList = true; } } }
void Client_UserEmoted(object sender, ChatMessageEventArgs e) { if (__userEmoted != null) { __userEmoted.Call(_host.ClientHost, ConvObj(e)); } }
/// <summary> /// Initializes a new instance of the <see cref="Message" /> class. /// </summary> /// <param name="args">The <see cref="GameChatEventArgs" /> instance containing the event data.</param> public Message(ChatMessageEventArgs args) { this.Content = args.Message; this.Sender = args.Sender; this.Time = Game.Time; this.Process = args.Process; }
private bool CommandsTooFast(ChatMessageEventArgs chatMessageArgs, ChatUserInfo user, string namedCommand, TimeSpan?cooldown = null) { Debug.Assert(user != null); if (chatMessageArgs.IsModerator || chatMessageArgs.IsOwner) { return(false); } var now = DateTime.UtcNow; if (now - user.LastCommandTime < CooldownTime) { _logger?.LogWarning($"Ignoring command {namedCommand} from {chatMessageArgs.UserName} on {chatMessageArgs.ServiceName}. Cooldown active"); return(true); } if (_commandExecutedTimeMap.TryGetValue(namedCommand, out var dt) && now - dt < cooldown.GetValueOrDefault()) { var remain = cooldown.GetValueOrDefault() - (now - dt); _logger?.LogWarning($"Ignoring command {namedCommand} from {chatMessageArgs.UserName} on {chatMessageArgs.ServiceName}. In cooldown for {(int)remain.TotalSeconds} more secs"); return(true); } return(false); }
public void SendChatToAll(ServerPlayer from, string chat, bool action) { if (chat == string.Empty) { return; } ChatMessageEventArgs args = new ChatMessageEventArgs(); args.From = from; args.To = null; args.MessageText = chat; args.Action = action; args.ChatType = from == null ? ChatMessageEventArgs.ChatMessageTypes.ServerAnnouncemnt : ChatMessageEventArgs.ChatMessageTypes.PublicMessage; MsgMessage msg = new MsgMessage(); msg.MessageText = chat; msg.From = from == null ? PlayerConstants.ServerPlayerID : from.PlayerID; msg.To = PlayerConstants.AllPlayersID; msg.MessageType = action ? MsgMessage.MessageTypes.ActionMessage : MsgMessage.MessageTypes.ChatMessage; Players.SendToAll(msg, false); MessageSent?.Invoke(this, args); }
public void SendChatToTeam(ServerPlayer from, TeamColors to, string chat, bool action) { if (chat == string.Empty) { return; } ChatMessageEventArgs args = new ChatMessageEventArgs(); args.From = from; args.To = null; args.ToTeam = to; args.MessageText = chat; args.Action = action; args.ChatType = from == null ? ChatMessageEventArgs.ChatMessageTypes.ServerTeamMessage : ChatMessageEventArgs.ChatMessageTypes.TeamMessage; if (args.ToTeam == TeamColors.NoTeam) { return; } MsgMessage msg = new MsgMessage(); msg.MessageText = chat; msg.From = from == null ? PlayerConstants.ServerPlayerID : from.PlayerID; msg.To = PlayerConstants.GetTeamPlayerID(to); msg.MessageType = action ? MsgMessage.MessageTypes.ActionMessage : MsgMessage.MessageTypes.ChatMessage; Players.SendToTeam(msg, to, false); MessageSent?.Invoke(this, args); }
public void SendChatToUser(ServerPlayer from, ServerPlayer to, string chat, bool action) { if (chat == string.Empty) { return; } ChatMessageEventArgs args = new ChatMessageEventArgs(); args.From = from; args.To = to; args.ToTeam = to.ActualTeam; args.MessageText = chat; args.Action = action; args.ChatType = from == null ? ChatMessageEventArgs.ChatMessageTypes.ServerPrivateMessage : ChatMessageEventArgs.ChatMessageTypes.PrivateMessage; if (args.To == null) { return; } MsgMessage msg = new MsgMessage(); msg.MessageText = chat; msg.From = from == null ? PlayerConstants.ServerPlayerID : from.PlayerID; msg.To = to.PlayerID; msg.MessageType = action ? MsgMessage.MessageTypes.ActionMessage : MsgMessage.MessageTypes.ChatMessage; to.SendMessage(true, msg); MessageSent?.Invoke(this, args); }
public void DispatchChatMessage(ChatMessageEventArgs messaage) { MessagePreSend?.Invoke(this, messaage); if (!messaage.Allow || messaage.ChatType == ChatMessageEventArgs.ChatMessageTypes.Unknown) { return; } switch (messaage.ChatType) { case ChatMessageEventArgs.ChatMessageTypes.PrivateMessage: case ChatMessageEventArgs.ChatMessageTypes.ServerPrivateMessage: SendChatToUser(messaage.From, messaage.To, messaage.MessageText, messaage.Action); return; case ChatMessageEventArgs.ChatMessageTypes.PublicMessage: case ChatMessageEventArgs.ChatMessageTypes.ServerAnnouncemnt: SendChatToAll(messaage.From, messaage.MessageText, messaage.Action); return; case ChatMessageEventArgs.ChatMessageTypes.TeamMessage: case ChatMessageEventArgs.ChatMessageTypes.ServerTeamMessage: SendChatToTeam(messaage.From, messaage.ToTeam, messaage.MessageText, messaage.Action); return; case ChatMessageEventArgs.ChatMessageTypes.GroupMessage: case ChatMessageEventArgs.ChatMessageTypes.ServerGroupMessage: SendChatToGroup(messaage.From, messaage.ToGroup, messaage.MessageText, messaage.Action); return; } }
public void FilterChat() { bool done = false; while (!done) { ChatMessageEventArgs message = PopInboundChat(); if (message == null) { done = true; } else { if (DefaultFilter != null) { message.Filtered = DefaultFilter(message); } MessageFilter?.Invoke(this, message); DispatchChatMessage(message); } } lock (PendingInboundChats) FilterWorker = null; }
public void SendChatToGroup(ServerPlayer from, GroupInfo to, string chat, bool action) { if (chat == string.Empty) { return; } ChatMessageEventArgs args = new ChatMessageEventArgs(); args.From = from; args.To = null; args.ToTeam = TeamColors.NoTeam; args.ToGroup = to; args.MessageText = chat; args.Action = action; args.ChatType = from == null ? ChatMessageEventArgs.ChatMessageTypes.ServerGroupMessage : ChatMessageEventArgs.ChatMessageTypes.GroupMessage; if (args.ToTeam == TeamColors.NoTeam) { return; } MsgMessage msg = new MsgMessage(); msg.MessageText = chat; msg.From = from == null ? PlayerConstants.ServerPlayerID : from.PlayerID; msg.To = to.BroadcastID; msg.MessageType = action ? MsgMessage.MessageTypes.ActionMessage : MsgMessage.MessageTypes.ChatMessage; to.SentTo(msg, false); MessageSent?.Invoke(this, args); }
protected internal virtual void OnChatMessage(ChatMessageEventArgs e) { if (ChatMessage != null) { ChatMessage(this, e); } }
private void AddPlayerChatMessage(object sender, ChatMessageEventArgs e) { int messageHash = messagesField.GetValue().Last().GetHashCode(); RemoveExcedentMessages(messageHash); string message = formatMessageMethod.Invoke <string>(e.SourcePlayer.UniqueMultiplayerID, e.ChatKind, e.Message); int witdh = Game1.chatBox.chatBox.Width; if (e.ChatKind == Constants.ChatMessageKind.Normal) { witdh -= 8; } message = Game1.parseText(message, Game1.chatBox.chatBox.Font, witdh - 8); PlayerMessageList.Add(new PlayerMessage(e.SourcePlayer, e.Language, message, messageHash)); foreach (ChatSnippet item in messagesField.GetValue().Last().message) { if (item.emojiIndex >= NumberVanillaEmoji) { item.emojiIndex = -1; } } }
static Chat() { ChatSubmitMessage.Subscribe(data => { var eventArgs = new ChatMessageEventArgs(G.Sys.PlayerManager_.Current_.profile_.Name_, data.message_); MessageSent?.Invoke(null, eventArgs); }); ChatMessage.Subscribe(data => { Console.WriteLine(data.message_); var author = ExtractMessageAuthor(data.message_); if (author != G.Sys.PlayerManager_.Current_.profile_.Name_ && !IsSystemMessage(data.message_)) { var eventArgs = new ChatMessageEventArgs(author, ExtractMessageBody(data.message_)); MessageReceived?.Invoke(null, eventArgs); } }); ToAllClientsRemotePlayerActionMessage.Subscribe(data => { if (G.Sys.NetworkingManager_.IsOnline_) { var nickname = G.Sys.PlayerManager_.PlayerList_[data.index_].Username_; var eventArgs = new ChatActionEventArgs(data.index_, nickname, data.message_); ActionReceived?.Invoke(null, eventArgs); } }); }
void MessageSent(object sender, ChatMessageEventArgs e) { if (m_inChat) { chat.AddChat(new ChatNode("[", CssClasses.SpeakBracketsOtherUsers), new ChatNode(m_userName, CssClasses.SpeakOtherUsername), new ChatNode("]: ", CssClasses.SpeakBracketsOtherUsers), new ChatNode(e.Text, CssClasses.SpeakText)); } }
private void OnMessageReceived(object sender, ChatMessageEventArgs e) { chatHistory.text += CreateMessageString(e); chatHistory.ForceMeshUpdate(); chatHistory.pageToDisplay = chatHistory.textInfo.pageCount; // go to the last page to show the new text CheckPageButtons(); }
private void MinecraftServerOnChatMessage(object sender, ChatMessageEventArgs chatMessageEventArgs) { var internalArgs = new ChatMessageEventArgs(chatMessageEventArgs.Origin, chatMessageEventArgs.RawMessage); if (ChatMessage != null) { ChatMessage(this, internalArgs); if (internalArgs.Handled) { chatMessageEventArgs.Handled = true; return; } } chatMessageEventArgs.Handled = true; if (chatMessageEventArgs.RawMessage.StartsWith("/")) { if (chatMessageEventArgs.RawMessage.StartsWith("//")) { MinecraftServer.SendChat(string.Format(SettingsProvider.Get <string>("chat.format"), chatMessageEventArgs.Origin.Username, chatMessageEventArgs.RawMessage.Substring(1))); } else { Command.ExecuteCommand(this, chatMessageEventArgs.Origin, chatMessageEventArgs.RawMessage); } } else { MinecraftServer.SendChat(string.Format(SettingsProvider.Get <string>("chat.format"), chatMessageEventArgs.Origin.Username, chatMessageEventArgs.RawMessage)); } }
private void ProcessCommand(ChatMessageEventArgs e, string contents) { string[] commandParts = contents.Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); string command = null; string[] parameters = new string[commandParts.Length - 1]; if (commandParts.Length > 0) { command = commandParts[0]; } if (commandParts.Length > 1) { Array.Copy(commandParts, 1, parameters, 0, parameters.Length); } IJinxBotPrincipal commander = m_client.Database.FindUsers(e.Username).FirstOrDefault(); if (commander != null) { foreach (ICommandHandler handler in m_client.CommandHandlers) { if (handler.HandleCommand(commander, command, parameters)) { break; } } } }
void Client_MessageSent(object sender, ChatMessageEventArgs e) { if (__messageSent != null) { __messageSent.Call(_host.ClientHost, ConvObj(e)); } }
private async void Client_ChatMessageSent(object sender, ChatMessageEventArgs e) { WasMessageEmpty = true; await Client.SendTypingState(false); Application.Current.Dispatcher.Invoke(() => ChatItems.Add(new Message(e.Message.Body, true))); }
protected internal void OnChatMessageReceived(ChatMessageEventArgs e) { if (ChatMessageReceived != null) { ChatMessageReceived(this, e); } }
public void ShouldLogIfCommandsToFast() { var sut = new FritzBot(_config.Object, _serviceProvider.Object, _loggerFactory.Object); Task.WaitAll(sut.StartAsync(new CancellationToken())); var args = new ChatMessageEventArgs { Message = "!help", ServiceName = "TestService", UserName = "******", IsModerator = false, IsOwner = false, }; _chatservice.Raise(cs => cs.ChatMessage += null, args); _chatservice.Raise(cs => cs.ChatMessage += null, args); const string expectWarning = "Ignoring command help from testusername on TestService. Cooldown active"; //_logger.Verify( // m => m.Log( // LogLevel.Warning, // It.IsAny<EventId>(), // //It.Is<FormattedLogValues>(v => v.ToString().Contains(expectWarning)), // It.IsAny<Exception>(), // It.IsAny<Func<object, Exception, string>>()) //); }
public static void ChatBoxAddedMessage(this ChatBox chatBox, string message, Color color) { ChatMessageKind messageKind; if (color == Game1.chatBox.chatBox.TextColor) { messageKind = ChatMessageKind.Normal; } else if (color == Color.Yellow) { messageKind = ChatMessageKind.Notification; } else { messageKind = ChatMessageKind.Error; } ChatMessageEventArgs args = new ChatMessageEventArgs { SourcePlayer = Game1.player, ChatKind = messageKind, Language = LocalizedContentManager.CurrentLanguageCode, Message = message }; #if DEBUG ModEntry.ModLogger.LogToMonitor = false; ModEntry.ModLogger.LogTrace(); ModEntry.ModLogger.LogToMonitor = true; #endif OnChatBoxAddedMessage(null, args); }
private void ChatClient_MessageRecivedEvent(object sender, ChatMessageEventArgs e) { foreach (var client in _clients.Where(x => sender != x)) { client.Send(e.Message); } }
void UserSpoke(object sender, ChatMessageEventArgs e) { chat.AddChat(new ChatNode("[", CssClasses.SpeakBracketsOtherUsers), new ChatNode(e.Username, CssClasses.SpeakOtherUsername), new ChatNode("]: ", CssClasses.SpeakBracketsOtherUsers), new ChatNode(e.Text, CssClasses.SpeakText)); }
/// <summary> /// Called when a chat message is received from a client. /// </summary> /// <param name="sender">The source of the event.</param> /// <param name="e">A <see cref="ChatMessageEventArgs"/> object containing the event data.</param> private void OnChatMessage(object sender, ChatMessageEventArgs e) { if (AdminManager.CheckAccess(e.Client, AdminFlags.Root)) { return; } this.minChatTimes.TryGetValue(e.Client.PlayerId, out var minChatTime); this.tokens.TryGetValue(e.Client.PlayerId, out var token); var time = DateTime.Now.Ticks; var nextTime = time + (long)(this.floodTime.AsFloat * 10000000); if (time < minChatTime) { if (token < 3) { this.tokens[e.Client.PlayerId] = token + 1; } else { nextTime += 30000000; e.Handled = true; } } else if (token > 0) { this.tokens[e.Client.PlayerId] = token - 1; } this.minChatTimes[e.Client.PlayerId] = nextTime; }
public void PushMessageToFilter(ChatMessageEventArgs message) { lock (PendingInboundChats) PendingInboundChats.Add(message); CheckFilterThread(); }
private async Task ProcessChatMessage(object sender, ChatMessageEventArgs chatMessageArgs) { if (!(sender is IChatService)) { return; } // TODO: Add queue processing to ensure only one instance of a command is executing at a time var userKey = $"{chatMessageArgs.ServiceName}:{chatMessageArgs.UserName}"; var user = _activeUsers.AddOrUpdate(userKey, new ChatUserInfo(), (_, u) => u); var chatService = sender as IChatService; if (await HandleExtendedCommands(chatService, chatMessageArgs, user)) { return; } if (chatMessageArgs.Message.FirstOrDefault() == '!') { if (!await HandleBasicCommands(chatService, chatMessageArgs, user)) { await chatService.SendWhisperAsync(chatMessageArgs.UserName, UnknownCommandMessage); } } }
void QuoteMessage(object sender, ChatMessageEventArgs e) { IChatMessage message = e.ChatMessage; switch (e.QuoteType) { case ChatMessageQuoteType.Quote: if (string.IsNullOrWhiteSpace(NewMessage)) { NewMessage = $"> {message.Text}\r\r@{message.FromUser.Username} "; } else if (NewMessage.EndsWith("\r") || NewMessage.EndsWith("\n")) { NewMessage = $"{NewMessage}\r> {message.Text}\r\r@{message.FromUser.Username} "; } else { NewMessage = $"{NewMessage}\r\r> {message.Text}\r\r@{message.FromUser.Username} "; } break; case ChatMessageQuoteType.Reply: NewMessage = $"{NewMessage} @{message.FromUser.Username} ".TrimStart(); break; default: break; } BuildClassString(NewMessage); Invoke(StateHasChanged); Task.Delay(1); }
public void OnIRCMessage(object sender, ChatMessageEventArgs e) { if (e.Sender == null || e.Message[0] != '!') { return; } var message = (string)e.Message; var messageArray = message.Split(' '); var command = RegisteredCommands.FirstOrDefault(cmd => cmd.Trigger.Equals(messageArray[0])); if (command == null) { return; } var input = message.Substring(messageArray[0].Length).Trim(); var commandData = new CommandArguments { CommandType = ECommandType.IRC, SenderIdentity = e.Sender, Recipient = e.Recipient, Message = input }; if (command.IsSteamCommand && !Steam.Instance.Client.IsConnected) { ReplyToCommand(commandData, "Not connected to Steam."); return; } else if (command.IsAdminCommand) { var ident = string.Format("{0}@{1}", e.Sender.Username, e.Sender.Hostname); if (!Settings.Current.IRC.Admins.Contains(ident)) { ReplyToCommand(commandData, "You're not an admin!"); return; } } else if (SteamDB.IsBusy()) { ReplyToCommand(commandData, "The bot is currently busy."); return; } Log.WriteInfo("CommandHandler", "Handling IRC command {0} for user {1} in channel {2}", message, e.Sender, e.Recipient); TryCommand(command, commandData); }
/// <summary> /// Game.OnChat event for the command line /// </summary> /// <param name="args">The args.</param> //private static void Game_OnChat(GameChatEventArgs args) private static void Game_OnChat(AIHeroClient sender, ChatMessageEventArgs args) { if (args.Sender.IsMe) { args.Process = false; var commands = args.Message.Split(' '); switch (commands[0]) { case "blockopcode": s_blockedOpcodes.Add(int.Parse(commands[1], NumberStyles.HexNumber)); Chat.Print("opcode {0} has blocked", commands[1]); break; case "unblockopcode": s_blockedOpcodes.Remove(int.Parse(commands[1], NumberStyles.HexNumber)); Chat.Print("opcode {0} has unblocked", commands[1]); break; case "showblockedopcodes": foreach (var opcode in s_blockedOpcodes) Chat.Print("{0:X2}", opcode); break; case "setdebugme": if (commands[1] != "0" && commands[1] != "1") { Chat.Print("setdebugme only accepets 1 or 0"); return; } s_debugReceivedOnlyWithMyNetId = Convert.ToBoolean(Convert.ToInt32(commands[1])); Chat.Print(s_debugReceivedOnlyWithMyNetId ? "Only debugging packets with my net id" : "Debugging all packets"); break; case "clearconsole": Console.Clear(); Chat.Print("console clear"); break; case "unblockallopcodes": s_blockedOpcodes.Clear(); Chat.Print("Clear all blocked opcodes"); break; case "setdebegopcode": s_debugOnlyOpcode = int.Parse(commands[1], NumberStyles.HexNumber); Chat.Print("Only debugging opcode {0} (to disable enter same command with FFFF)", commands[1]); break; default: args.Process = true; break; } } }
private static void Chat_OnMessage(AIHeroClient sender, ChatMessageEventArgs args) { using (var sw = new StreamWriter(LogFile, true)) { //store the current stopwatch millisecond for accurate results long elapsedTime = Stopwatch.ElapsedMilliseconds; //compute elapsed minutes long elapsedMinutes = elapsedTime / 60000; //create a variable to store the seconds in long elapsedSeconds = 0; //compute the elapsed seconds and store it in the variable previously created Math.DivRem(elapsedTime, 60000, out elapsedSeconds); elapsedSeconds /= 1000; //write everything to the stream sw.WriteLine("[" + elapsedMinutes + ":" + (elapsedSeconds < 10 ? "0" : "") + elapsedSeconds + "] " + args.Sender.Name + " (" + args.Sender.ChampionName + "): " + args.Message); //close the stream sw.Close(); } }
private void HandleChatMessageEvent(ChatMessageEventArgs cmArgs) { switch (cmArgs.EventType) { case ChatEventType.Emote: OnUserEmoted(cmArgs); break; case ChatEventType.Talk: OnUserSpoke(cmArgs); break; case ChatEventType.WhisperReceived: OnWhisperReceived(cmArgs); break; case ChatEventType.WhisperSent: OnWhisperSent(cmArgs); break; } }
private void OnRecieveChatMessage(object o, ChatMessageEventArgs e) { chatLog += e.Message + "\r\n"; chatLogText.text = chatLog; scrollBar.value = 0; }
public void OnMessageSent(ChatMessageEventArgs e) { m_host.OnMessageSent(e); }
private static void Chat_OnMessage(AIHeroClient sender, ChatMessageEventArgs args) { if (args.Message.Contains("leesin debug:") && !Menuini.checkbox("debug")) { args.Process = false; } }
public void OnUserEmoted(ChatMessageEventArgs e) { m_host.OnUserEmoted(e); }
private void OnChatMessageReceived(object sender, ChatMessageEventArgs e) { if (String.Equals(e.ChatMessage.Source, Chat.Client.Connection.ConnectionData.Nickname, StringComparison.OrdinalIgnoreCase) && String.Equals(e.ChatMessage.Command, "JOIN", StringComparison.OrdinalIgnoreCase)) { this.updateTimer.Start(); } }
private void HandleChatEvent(ParseData data) { DataReader dr = new DataReader(data.Data); ChatEventType type = (ChatEventType)dr.ReadInt32(); int flags = dr.ReadInt32(); int ping = dr.ReadInt32(); dr.Seek(12); string user = dr.ReadCString(); byte[] userInfo = dr.ReadNullTerminatedByteArray(); string text = Encoding.ASCII.GetString(userInfo); switch (type) { case ChatEventType.UserInChannel: case ChatEventType.UserJoinedChannel: ChatUser newUser = new ChatUser(user, ping, (UserFlags)flags, UserStats.Parse(user, userInfo)); if (m_namesToUsers.ContainsKey(user)) { m_namesToUsers.Remove(user); } m_namesToUsers.Add(user, newUser); UserEventArgs uArgs = new UserEventArgs(type, newUser); HandleUserChatEvent(uArgs); break; case ChatEventType.UserFlagsChanged: if (m_namesToUsers.ContainsKey(user)) { ChatUser changedUser = m_namesToUsers[user]; changedUser.Flags = (UserFlags)flags; UserEventArgs updatedArgs = new UserEventArgs(type, changedUser); HandleUserChatEvent(updatedArgs); } else if (m_channelName.Equals("The Void", StringComparison.OrdinalIgnoreCase)) { ChatUser voidUser = new ChatUser(user, ping, (UserFlags)flags, UserStats.Parse(user, userInfo)); m_namesToUsers.Add(user, voidUser); UserEventArgs voidArgs = new UserEventArgs(type, voidUser); HandleUserChatEvent(voidArgs); } break; case ChatEventType.UserLeftChannel: if (m_namesToUsers.ContainsKey(user)) { ChatUser goneUser = m_namesToUsers[user]; UserEventArgs leftArgs = new UserEventArgs(type, goneUser); HandleUserChatEvent(leftArgs); } break; case ChatEventType.Emote: case ChatEventType.Talk: case ChatEventType.WhisperReceived: case ChatEventType.WhisperSent: ChatMessageEventArgs cmArgs = new ChatMessageEventArgs(type, (UserFlags)flags, user, Encoding.UTF8.GetString(userInfo)); HandleChatMessageEvent(cmArgs); break; case ChatEventType.NewChannelJoined: ServerChatEventArgs joinArgs = new ServerChatEventArgs(type, flags, text); m_channelName = text; m_namesToUsers.Clear(); OnJoinedChannel(joinArgs); break; case ChatEventType.Broadcast: case ChatEventType.ChannelDNE: case ChatEventType.ChannelFull: case ChatEventType.ChannelRestricted: case ChatEventType.Error: case ChatEventType.Information: ServerChatEventArgs scArgs = new ServerChatEventArgs(type, flags, text); HandleServerChatEvent(scArgs); break; } BattleNetClientResources.IncomingBufferPool.FreeBuffer(data.Data); }
public void OnUserSpoke(ChatMessageEventArgs e) { m_host.OnUserSpoke(e); }
public void OnWhisperReceived(ChatMessageEventArgs e) { m_host.OnWhisperReceived(e); }
public void OnWhisperSent(ChatMessageEventArgs e) { m_host.OnWhisperSent(e); }
private void Chat_OnMessage(AIHeroClient sender, ChatMessageEventArgs args) { if (!args.Message.StartsWith("<font color=\"#40c1ff\">Challenjour Ryze")) return; if (args.Message.Contains("have fun")) Core.DelayAction(() => Chat.Say("gl hf"), RandGen.r.Next(2000, 4000)); if (args.Message.Contains("hello")) Core.DelayAction(() => Chat.Say("hi Christian"), RandGen.r.Next(2000, 4000)); if (args.Message.Contains("Which")||args.Message.Contains("Whats")) Core.DelayAction(() => Chat.Say(Assembly.GetExecutingAssembly().GetName().Version.Revision.ToString()), RandGen.r.Next(2000, 4000)); if (args.Message.Contains("go top please.")) { Core.DelayAction(() => Chat.Say("kk"), RandGen.r.Next(1000, 2000)); Core.DelayAction(() => SelectLane2(Lane.Top), RandGen.r.Next(2500, 4000)); } if (args.Message.Contains("go mid please.")) { Core.DelayAction(() => Chat.Say("ok"), RandGen.r.Next(1000, 2000)); Core.DelayAction(() => SelectLane2(Lane.Mid), RandGen.r.Next(2500, 4000)); } if (args.Message.Contains("go bot please.")) { Core.DelayAction(() => Chat.Say("k"), RandGen.r.Next(1000, 2000)); Core.DelayAction(() => SelectLane2(Lane.Bot), RandGen.r.Next(2500, 4000)); } if (args.Message.Contains("go where you want.")) { Core.DelayAction(() => Chat.Say("yes sir"), RandGen.r.Next(1000, 2000)); Core.DelayAction(SelectLane, RandGen.r.Next(2500, 4000)); } if (args.Message.Contains("Thank you")) { Core.DelayAction(() => Chat.Say("np"), RandGen.r.Next(1000, 2000)); Core.DelayAction(SelectLane, RandGen.r.Next(2500, 4000)); } }
private void _ircClient_GotMessage(object sender, ChatMessageEventArgs e) { string string1 = Encoding.UTF8.GetString(e.Sender.Nickname); Color color = Color.Blue; foreach (string str in ircUserList.Items) { if (!(str.Substring(1) != string1)) { switch (Enumerable.ElementAt(str, 0)) { case '%': color = Color.DodgerBlue; goto label_11; case '+': color = Color.ForestGreen; goto label_11; case '@': color = Color.Red; goto label_11; default: goto label_11; } } } label_11: RichTextBoxExtensions.AppendText(ircMessageBox, Environment.NewLine + e.Sender.Nickname + ": ", color); string string2 = Encoding.UTF8.GetString(e.Message); RichTextBoxExtensions.AppendText(ircMessageBox, string2, string2.ToUpper().Contains(_ircNickname.ToUpper()) ? Color.Red : Color.Black); RichTextBoxExtensions.ScrollToEnd(ircMessageBox); }
private void _ircClient_GotNotice(object sender, ChatMessageEventArgs e) { statusBox.Items.Add("Notice: " + e.Message); if (!(e.Message == "please choose a different nick.")) return; ircUserList.Items.Remove(_ircNickname); _ircNickname = Program.AccountName + "_" + (new Random().Next(0, 1000)).ToString(); // AFFSD BEGIN AFFSD END statusBox.Items.Add("Retrying with a new nickname \"" + _ircNickname + "\" ..."); _ircClient.ChangeName(_ircNickname); ircUserList.Items.Add(_ircNickname); }
private static void OnChat(AIHeroClient sender, ChatMessageEventArgs args) { if (Menu["logall"].Cast<CheckBox>().CurrentValue) { using (var sw = new StreamWriter(LogFile, true)) { long elapsedTime = Stopwatch.ElapsedMilliseconds; long elapsedMinutes = elapsedTime / 60000; long elapsedSeconds = 0; Math.DivRem(elapsedTime, 60000, out elapsedSeconds); elapsedSeconds /= 1000; sw.WriteLine("[" + elapsedMinutes + ":" + (elapsedSeconds < 10 ? "0" : "") + elapsedSeconds + "] " + args.Message.ToString() .Replace("<font color=\"#ff3333\">", "") .Replace("<font color=\"#40c1ff\">", "") .Replace("<font color=\"#ffffff\">", "") .Replace("</font>", "")); sw.Close(); } } if (Menu["logcall"].Cast<CheckBox>().CurrentValue) { var msg = args.Message.ToLower(); if (msg.Contains("hack") || msg.Contains("autoplay") || msg.Contains("macro") || msg.Contains("script") || msg.Contains("report") || msg.Contains("ticket") || msg.Contains("bol") || msg.Contains("leaguesharp") || msg.Contains("elobuddy")) { using (var cw = new StreamWriter(CalloutsFile, true)) { long elapsedTime = Stopwatch.ElapsedMilliseconds; long elapsedMinutes = elapsedTime / 60000; long elapsedSeconds = 0; Math.DivRem(elapsedTime, 60000, out elapsedSeconds); elapsedSeconds /= 1000; cw.WriteLine("[" + elapsedMinutes + ":" + (elapsedSeconds < 10 ? "0" : "") + elapsedSeconds + "] " + args.Message.ToString() .Replace("<font color=\"#ff3333\">", "") .Replace("<font color=\"#40c1ff\">", "") .Replace("<font color=\"#ffffff\">", "") .Replace("</font>", "")); cw.Close(); } } } }
void ChatService_NewMessage(object sender, ChatMessageEventArgs e) { throw new NotImplementedException(); }
// Implements the actual sending of the text. This method is called as the callback referenced by m_messageReadyCallback, hooked into // the queue's MessageReady event. private void SendCallbackImpl(string text) { if (IsConnected) { BncsPacket pck = new BncsPacket((byte)BncsPacketId.ChatCommand); pck.InsertCString(text, Encoding.UTF8); Send(pck); if (text.StartsWith(EMOTE_1, StringComparison.OrdinalIgnoreCase) || text.StartsWith(EMOTE_2, StringComparison.OrdinalIgnoreCase)) { // do nothing, but we need this case first so that command sent doesn't fire for emotes. } else if (text.StartsWith(COMMAND_START, StringComparison.Ordinal)) { OnCommandSent(new InformationEventArgs(text)); } else { ChatMessageEventArgs cme = new ChatMessageEventArgs(ChatEventType.Talk, UserFlags.None, this.m_uniqueUN, text); OnMessageSent(cme); } } }
/// <summary> /// Hooks any messages. /// </summary> /// <param name="args">EventArgs</param> /// <param name="sender">Sender</param> private static void OnMessage(AIHeroClient sender, ChatMessageEventArgs args) { }
/// <summary> /// KeyDown callback to process the input. /// </summary> /// <param name="sender"></param> /// <param name="e"></param> private void ChatInput_OnKeyDown(object sender, KeyEventArgs e) { // Play the chat click sound.. var playSound = Detox.Terraria.GetType("Terraria.Main").GetMethod("PlaySound", new[] { typeof(int), typeof(int), typeof(int), typeof(int) }); if (playSound != null) playSound.Invoke(null, new object[] { 12, -1, -1, 1 }); // Obtain the message to send.. var message = this._chatInput.Text.Trim(); // Process the enter key.. if ((e.Key == Keys.Enter) && !string.IsNullOrEmpty(message)) { // Send the current message.. var msg = new ChatMessageEventArgs(new ChatMessage { Color = Color.White, Message = message, Timestamp = DateTime.Now }); this.MessageSent(this, msg); e.Handled = true; // Update the control.. this._chatInput.Text = string.Empty; base.ClientArea.Invalidate(); this.CalculateScrolling(); } // Cleanup invalid text.. else if ((e.Key == Keys.Enter) && string.IsNullOrEmpty(message)) { this._chatInput.Text = string.Empty; e.Handled = true; } }
private static void OnNotice(object sender, ChatMessageEventArgs chatMessageEventArgs) { var information = MethodBase.GetCurrentMethod().Name; try { var serverUser = GetServerUser(sender); serverUser.OnMessage(MessageType.Notice, chatMessageEventArgs); } catch (Exception ex) { Console.WriteLine("{0} exception {1}", information, ex.Message); } }
private static void Chat_OnMessage(AIHeroClient sender, ChatMessageEventArgs args) { if (Logger["EnabledLog"].Cast<CheckBox>().CurrentValue) { try { AddToLog(args.Message, args.Sender); } catch (Exception) { Console.WriteLine("Error at adding log"); } } if (IncomingText["Enabled"].Cast<CheckBox>().CurrentValue && !args.Sender.IsMe) { AddMessage(args.Message, args.Sender); } else { AddMessage(args.Message, args.Sender, false); } }
private static void OnMessage(Obj_AI_Base sender, ChatMessageEventArgs args) { if (!menu["BLOCKTEAM"].Cast<CheckBox>().CurrentValue) return; var ally = sender as AIHeroClient; if (!sender.IsMe && sender.IsAlly && WordList.Any(x => args.Message.ToLower().Contains(x))) { TeamToxicCount[ally.ChampionName]++; if (TeamToxicCount[ally.ChampionName] == 9) Chat.Print(ally.ChampionName + " Will Get Muted If He Says Another Bad Word!"); } }
public void OnIRCMessage(object sender, ChatMessageEventArgs e) { var commandData = new CommandArguments { CommandType = ECommandType.IRC, SenderIdentity = e.Sender, Recipient = e.Recipient, Message = e.Message }; if (Steam.Instance.Client.IsConnected) { PubFileHandler.OnMessage(commandData); } LinkExpander.OnMessage(commandData); if (e.Message[0] != Settings.Current.IRC.CommandPrefix) { return; } var message = (string)e.Message; var messageArray = message.Split(' '); var trigger = messageArray[0]; if (trigger.Length < 2) { return; } trigger = trigger.Substring(1); var command = RegisteredCommands.FirstOrDefault(cmd => cmd.Trigger.Equals(trigger)); if (command == null) { return; } commandData.Message = message.Substring(messageArray[0].Length).Trim(); if (command.IsSteamCommand && !Steam.Instance.Client.IsConnected) { commandData.Reply("Not connected to Steam."); return; } if (command.IsAdminCommand) { var ident = string.Format("{0}@{1}", e.Sender.Username, e.Sender.Hostname); if (!Settings.Current.IRC.Admins.Contains(ident)) { return; } } Log.WriteInfo("CommandHandler", "Handling IRC command \"{0}\" for {1}", message, commandData); TryCommand(command, commandData); }
static void Client_UserSpoke(object sender, ChatMessageEventArgs<UserFlags> args) { PrintTidTs(DateTime.Now); console.OutputForegroundColor = ConsoleColor.Yellow; console.Write(args.Username); console.OutputForegroundColor = ConsoleColor.Gray; console.Write(": "); console.OutputForegroundColor = ConsoleColor.White; console.WriteLine(args.Text); console.OutputForegroundColor = ConsoleColor.Gray; }
/// <summary> /// The on message. /// </summary> /// <param name="messageType"> /// The message type. /// </param> /// <param name="chatMessageEventArgs"> /// The chat message event args. /// </param> internal void OnMessage(EventDispatcher.MessageType messageType, ChatMessageEventArgs chatMessageEventArgs) { string message = chatMessageEventArgs.Message; var channel = this.GetChannel(chatMessageEventArgs.Recipient, true); var command = this.GetCommand(chatMessageEventArgs.Message); if (null == channel) { // This message/command was a personal message to the bot. Debug.WriteLine( string.Format( "Message \"{0}\" (from {1} to {2})", message, (chatMessageEventArgs.Sender != null) ? chatMessageEventArgs.Sender.Nickname.ToString() : "Anonymous", chatMessageEventArgs.Recipient), this.ToString()); return; } // A channel message/command if (null == command) { // A message channel.OnMessage(messageType, message, chatMessageEventArgs.Sender); } else { // A command channel.OnCommand(messageType, command, GetParameters(message), chatMessageEventArgs.Sender); } }
static void Client_UserEmoted(object sender, ChatMessageEventArgs<UserFlags> args) { PrintTidTs(DateTime.Now); console.OutputForegroundColor = ConsoleColor.Yellow; console.WriteLine("<{0} {1}>", args.Username, args.Text); console.OutputForegroundColor = ConsoleColor.Gray; }
private static void Chat_OnMessage(AIHeroClient sender, ChatMessageEventArgs args) { args.Message = StripSummonerNames(args.Message); }
static void client_WhisperReceived(object sender, ChatMessageEventArgs<UserFlags> e) { PrintTidTs(DateTime.Now); console.OutputForegroundColor = ConsoleColor.Magenta; console.WriteLine("{0} whispers: {1}", e.Username, e.Text); }