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);
}
