public override void ProcessMenssage(IrcClient.IrcMessage message, string[] args) { try { switch (args[1]) { case "list": this.IrcBot.SendChannelMessage("*** Listing Addons ***"); int i = 0; foreach (string name in this.IrcBot.AddonsList.Keys) { this.IrcBot.SendChannelMessage("*** " + (i + 1) + ".- " + name + ((this.IrcBot.AddonsList[name].IsStarted) ? " ( Running )" : "")); i++; } break; case "start": if (this.IrcBot.AddonsList.ContainsKey(args[2])) this.IrcBot.AddonsList[args[2]].Start(); this.IrcBot.SendChannelMessage(" >> " + args[2] + " started."); break; case "stop": if (this.IrcBot.AddonsList.ContainsKey(args[2])) this.IrcBot.AddonsList[args[2]].Stop(); this.IrcBot.SendChannelMessage(" >> " + args[2] + " stoped."); break; default: break; } } catch { }
public virtual void StartModule(IrcClient irc, Server server) { this.server = server; this.irc = irc; AddBindings(); Load(); }
public static void HandleUserListEnd(IrcClient client, IrcMessage message) { var channel = client.Channels[message.Parameters[1]]; client.OnChannelListRecieved(new ChannelEventArgs(channel)); if (client.Settings.ModeOnJoin) client.GetMode(channel.Name, c => Console.WriteLine(c.Mode)); }
public static void HandleWhoIsEnd(IrcClient client, IrcMessage message) { var request = client.RequestManager.DequeueOperation("WHOIS " + message.Parameters[1]); if(request.Callback != null) request.Callback(request); client.OnWhoIsReceived(new Events.WhoIsReceivedEventArgs((WhoIs)request.State)); }
public void ProcessCommand(string[] args, IrcClient client, IrcController controller) { if (args.Length == 0) { new NeedMoreParamsError { Command = "JOIN", SenderAddress = Server.HostName, SenderNickName = client.NickName }.SendMessageToClient(client); return; } var name = args[0].Trim(); if (!name.StartsWith("#")) { new NoSuchChannelError { SenderAddress = Server.HostName, ChannelName = name, ClientNick = client.NickName }.SendMessageToClient(client); return; } if (name.StartsWith("#")) name = name.Substring(1); controller.JoinChannel(client, name); }
public IrcBot(Server server) { this.server = server; irc = new IrcClient(server.nick, server.user, server.real, server.host); operatorList = new OperatorList(irc, server); LoadAllModules(Config.I.vars["ModuleLocation"]); }
/// <summary> /// Constructor to create an instace of IrcMessageData /// </summary> /// <param name="ircclient">IrcClient the message originated from</param> /// <param name="from">combined nickname, identity and host of the user that sent the message (nick!ident@host)</param> /// <param name="nick">nickname of the user that sent the message</param> /// <param name="ident">identity (username) of the userthat sent the message</param> /// <param name="host">hostname of the user that sent the message</param> /// <param name="channel">channel the message originated from</param> /// <param name="message">message</param> /// <param name="rawmessage">raw message sent by the server</param> /// <param name="type">message type</param> /// <param name="replycode">message reply code</param> public IrcMessageData(IrcClient ircclient, string from, string nick, string ident, string host, string channel, string message, string rawmessage, ReceiveType type, ReplyCode replycode) { _Irc = ircclient; _RawMessage = rawmessage; _RawMessageArray = rawmessage.Split(new[] {' '}); _Type = type; _ReplyCode = replycode; _From = from; _Nick = nick; _Ident = ident; _Host = host; _Channel = channel; if (message != null) { // message is optional _Message = message; _MessageArray = message.Split(new[] {' '}); } }
public static void HandleGetEmptyTopic(IrcClient client, IrcMessage message) { var channel = client.Channels.GetOrAdd(message.Parameters[1]); var old = channel._Topic; channel._Topic = message.Parameters[2]; client.OnChannelTopicReceived(new ChannelTopicEventArgs(channel, old, channel._Topic)); }
public static void HandleUserListPart(IrcClient client, IrcMessage message) { var channel = client.Channels[message.Parameters[2]]; var users = message.Parameters[3].Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); foreach (var nick in users) { if (string.IsNullOrWhiteSpace(nick)) continue; var mode = client.ServerInfo.GetModeForPrefix(nick[0]); if (mode == null) { var user = client.Users.GetOrAdd(nick); if (!user.Channels.Contains(channel)) user.Channels.Add(channel); if (!user.ChannelModes.ContainsKey(channel)) user.ChannelModes.Add(channel, null); else user.ChannelModes[channel] = null; } else { var user = client.Users.GetOrAdd(nick.Substring(1)); if (!user.Channels.Contains(channel)) user.Channels.Add(channel); if (!user.ChannelModes.ContainsKey(channel)) user.ChannelModes.Add(channel, mode.Value); else user.ChannelModes[channel] = mode.Value; } } }
public static void HandleMOTDNotFound(IrcClient client, IrcMessage message) { client.OnMOTDRecieved(new ServerMOTDEventArgs(MOTD)); client.OnConnectionComplete(new EventArgs()); VerifyOurIdentity(client); }
public IrcPacket(IrcClient irc, string prefix, string action, StringStream content, string origString) : base(action, content) { this.irc = irc; this.prefix = prefix; this.origString = origString; }
public static void HandleEndOfMOTD(IrcClient client, IrcMessage message) { client.OnMOTDRecieved(new ServerMOTDEventArgs(MOTD)); client.OnConnectionComplete(new EventArgs()); // Verify our identity VerifyOurIdentity(client); }
public static void HandleWhoIsUser(IrcClient client, IrcMessage message) { var whois = (WhoIs)RequestOperation.PeekOperation("WHOIS " + message.Parameters[1]).State; whois.User.Nick = message.Parameters[1]; whois.User.User = message.Parameters[2]; whois.User.Hostname = message.Parameters[3]; whois.User.RealName = message.Parameters[5]; }
public OperatorList(IrcClient irc, Server server) { this.server = server; Load(); this.irc = irc; irc.OnQuitRecvd += new IrcClient.JoinRecvd(irc_OnQuitRecvd); irc.OnNickRecvd += new IrcClient.JoinRecvd(irc_OnNickRecvd); }
public static void HandleJoin(IrcClient client, IrcMessage message) { var channel = client.Channels.GetOrAdd(message.Parameters[0]); var user = client.Users.GetOrAdd(message.Prefix); user.Channels.Add(channel); if (channel != null) client.OnUserJoinedChannel(new ChannelUserEventArgs(channel, new IrcUser(message.Prefix))); }
public static void HandleInviteListPart(IrcClient client, IrcMessage message) { var parameterString = message.RawMessage.Substring(message.RawMessage.IndexOf(' ') + 1); var parameters = parameterString.Substring(parameterString.IndexOf(' ') + 1).Split(' '); var request = client.RequestManager.PeekOperation("GETMODE I " + parameters[1]); var list = (MaskCollection)request.State; list.Add(new Mask(parameters[2], new IrcUser(parameters[3]), IrcClient.DateTimeFromIrcTime(int.Parse(parameters[4])))); }
public static void HandlePart(IrcClient client, IrcMessage message) { if (client.User.Match(message.Prefix)) // We've parted this channel client.Channels.Remove(client.Channels[message.Parameters[0]]); else // Someone has parted a channel we're already in client.Channels[message.Parameters[0]].Users.Remove(new IrcUser(message.Prefix).Nick); client.OnUserPartedChannel(new ChannelUserEventArgs(client.Channels[message.Parameters[0]], new IrcUser(message.Prefix))); }
public static void HandleMOTD(IrcClient client, IrcMessage message) { if (message.Parameters.Length != 2) throw new IrcProtocolException("372 MOTD message is incorrectly formatted."); var part = message.Parameters[1].Substring(2); MOTD += part + Environment.NewLine; client.OnMOTDPartRecieved(new ServerMOTDEventArgs(part)); }
public static void HandleQuietListPart(IrcClient client, IrcMessage message) { var parameterString = message.RawMessage.Substring(message.RawMessage.IndexOf(' ') + 1); var parameters = parameterString.Substring(parameterString.IndexOf(' ') + 1).Split(' '); var request = RequestOperation.PeekOperation("QLIST " + parameters[1]); var list = (List<Mask>)request.State; list.Add(new Mask(parameters[2], new IrcUser(parameters[3]), IrcClient.DateTimeFromIrcTime(int.Parse(parameters[4])))); }
public static void HandleMode(IrcClient client, IrcMessage message) { string target, mode = null; int i = 2; if (message.Command == "MODE") { target = message.Parameters[0]; mode = message.Parameters[1]; } else { target = message.Parameters[1]; mode = message.Parameters[2]; i++; } var eventArgs = new ModeChangeEventArgs(target, new IrcUser(message.Prefix), mode); client.OnModeChanged(eventArgs); // Handle change bool add = mode[0] == '+'; mode = mode.Substring(1); if (target.StartsWith("#")) { var channel = client.Channels[target]; foreach (char c in mode) { // TODO: Handle other types of MODEs if (channel.Mode == null) channel.Mode = string.Empty; if (add) { if (!channel.Mode.Contains(c)) channel.Mode += c.ToString(); } else channel.Mode = channel.Mode.Replace(c.ToString(), string.Empty); } if (message.Command == "324") { var operation = client.RequestManager.DequeueOperation("MODE " + channel.Name); operation.Callback(operation); } } else { // TODO: Handle user modes other than ourselves? foreach (char c in mode) { if (add) { if (!client.User.Mode.Contains(c)) client.User.Mode += c; } else client.User.Mode = client.User.Mode.Replace(c.ToString(), string.Empty); } } }
public JointTrigger(IrcClient client) { Client = client; Nicks = new List<String>() { "gaenone", "gaentwo", "gaenthree" }; Names = new List<string>(); Adjectives = new List<string>(); LoadNames(); LoadAdjectives(); }
public static void IrcClientList() { IrcClient irc = new IrcClient(); irc.OnRawMessage += new IrcEventHandler(IrcClientListCallback); irc.Connect(SERVER, PORT); irc.Login(NICK, REALNAME); irc.RfcList(CHANNEL); irc.Listen(); }
public static void HandleErronousNick(IrcClient client, IrcMessage message) { var eventArgs = new ErronousNickEventArgs(client.User.Nick); if (message.Command == "433") // Nick in use client.OnNickInUse(eventArgs); // else ... TODO if (!eventArgs.DoNotHandle) client.Nick(eventArgs.NewNick); }
public static void HandleWhoIsChannels(IrcClient client, IrcMessage message) { var whois = (WhoIs)RequestOperation.PeekOperation("WHOIS " + message.Parameters[1]).State; var channels = message.Parameters[2].Split(new[] { ' ' }, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < channels.Length; i++) if (!channels[i].StartsWith("#")) channels[i] = channels[i].Substring(1); whois.Channels = whois.Channels.Concat(channels).ToArray(); }
public static void HandleQuit(IrcClient client, IrcMessage message) { var user = new IrcUser(message.Prefix); if (client.User.Nick != user.Nick) { client.Users.Remove(user); client.OnUserQuit(new UserEventArgs(user)); } }
public static void HandleWhoIsEnd(IrcClient client, IrcMessage message) { var request = client.RequestManager.DequeueOperation("WHOIS " + message.Parameters[1]); var whois = (WhoIs)request.State; if (!client.Users.Contains(whois.User.Nick)) client.Users.Add(whois.User); if (request.Callback != null) request.Callback(request); client.OnWhoIsReceived(new Events.WhoIsReceivedEventArgs(whois)); }
public static void HandleWhoIsUser(IrcClient client, IrcMessage message) { if(message.Parameters != null && message.Parameters.Length >= 6) { var whois = (WhoIs)client.RequestManager.PeekOperation("WHOIS " + message.Parameters[1]).State; whois.User.Nick = message.Parameters[1]; whois.User.User = message.Parameters[2]; whois.User.Hostname = message.Parameters[3]; whois.User.RealName = message.Parameters[5]; } }
private void ircBot_SendingMesssage(object sender, IrcClient.IrcDataEventArgs e) { foreach (string user in this.IrcBot.MessagesByUser.Keys) { if (this.IrcBot.MessagesByUser[user].Count >10) { e.Cancel = true; } } }
public static void SendMessageToClient(this ISentCommand command, IrcClient client) { if (client == null) throw new ArgumentNullException("client"); if (command == null) throw new ArgumentNullException("command"); client.SendMessage(command.FormFullResponseString()); }
public static void HandleUserListPart(IrcClient client, IrcMessage message) { var channel = client.Channels[message.Parameters[2]]; var users = message.Parameters[3].Split(new[] {' '}, StringSplitOptions.RemoveEmptyEntries); for (int i = 0; i < users.Length; i++) { var user = users[i]; // TODO: Handle prefixes channel.Users.Add(new IrcUser(user)); } }
public IRC(string server, int port, string nick, string channel, string loginName, string authstring, string authuser, string targetGuild, string targetChannel, bool logMessages) { ircClient = new IrcClient(); ircClient.Encoding = System.Text.Encoding.UTF8; ircClient.SendDelay = 200; ircClient.ActiveChannelSyncing = true; ircClient.AutoRetry = true; ircClient.AutoRejoin = true; ircClient.AutoRelogin = true; ircClient.AutoRejoinOnKick = true; ircClient.OnError += this.OnError; ircClient.OnChannelMessage += this.OnChannelMessage; ircClient.OnDisconnected += this.OnDisconnected; timer = new System.Timers.Timer(); timer.Elapsed += Timer_Callback; timer.Enabled = true; timer.AutoReset = true; timer.Interval = TimeSpan.FromSeconds(30.0).TotalMilliseconds; /* Connection Info */ this.server = server; this.port = port; this.nick = nick; this.channel = channel; this.loginName = loginName; this.authstring = authstring; this.authuser = authuser; this.targetGuild = targetGuild; this.targetChannel = targetChannel; this.logMessages = logMessages; }
public Spam(IrcClient client) { Channels = new Dictionary <string, SpamConfig>(); var path = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "config", "spam.json"); if (File.Exists(path)) { var data = File.ReadAllText(path); try { Channels = JsonConvert.DeserializeObject <Dictionary <string, SpamConfig> >(data, new JsonSerializerSettings { MissingMemberHandling = MissingMemberHandling.Error }); foreach (var channel in Channels) { channel.Value.LastActions.Limit = Math.Max(channel.Value.LinesThreshold, channel.Value.RepeatThreshold) * 2; } } catch (JsonException e) { Log.WriteError("Spam", "Failed to parse spam.json file: {0}", e.Message); Environment.Exit(1); } } else { Log.WriteWarn("Spam", "File config/spam.json doesn't exist"); } client.GotMessage += OnMessage; client.GotChatAction += OnMessage; client.GotLeaveChannel += OnLeaveChannel; client.GotUserQuit += OnUserQuit; }
private static void HandleEventLoop(IrcClient client) { bool isExit = false; while (!isExit) { Console.Write("> "); var command = Console.ReadLine(); switch (command) { case "exit": isExit = true; break; case "join": if (!string.IsNullOrEmpty(command)) { client.SendRawMessage("JOIN #" + command); } break; default: if (!string.IsNullOrEmpty(command)) { if (command.StartsWith("/") && command.Length > 1) { client.SendRawMessage(command.Substring(1)); } else { Log.Logger.OutputToConsole("unknown command '{0}'", command); } } break; } } client.Disconnect(); }
private void ReadChatCommand(IrcClient client, IIrcMessageSource source, IList <IIrcMessageTarget> targets, string command, string[] parameters) { var defaultReplyTarget = GetDefaultReplyTarget(client, source, targets); ChatCommandProcessor processor; if (this.chatCommandProcessors.TryGetValue(command, out processor)) { System.Threading.Tasks.Task.Factory.StartNew(() => { try { processor(client, source, targets, command, parameters); } catch (InvalidCommandParametersException exInvalidCommandParameters) { client.LocalUser.SendNotice(defaultReplyTarget, exInvalidCommandParameters.GetMessage(command)); } catch (Exception ex) { if (source is IIrcMessageTarget) { client.LocalUser.SendNotice(defaultReplyTarget, "Error processing '{0}' command: {1}", command, ex.Message); } } }, System.Threading.Tasks.TaskCreationOptions.LongRunning); } else { if (source is IIrcMessageTarget) { client.LocalUser.SendNotice(defaultReplyTarget, "Command '{0}' not recognized.", command); } } }
public void RunCommand(IrcClient client, GroupCollection values, IrcEventArgs eventArgs, IrcBot ircBot) { RandomKickConfigModel config = ConfigHelpers.LoadConfig <RandomKickConfigModel>(ConfigHelpers.ConfigPaths.RandomKickConfig); if (!config.Enabled) { return; } RandomKickConfigModel.RandomKickTarget target = config.Targets.FirstOrDefault(t => t.Nick == eventArgs.Data.From.GetNick()); if (target == null) { return; } // Adding the target chance is just so that it doesn't end up with negative numbers // I don't know if negatives would be an issue but let's not find out the hard way int rangeBase = new Random(Guid.NewGuid().GetHashCode()).Next(0 + target.Chance, config.ChanceThreshold + target.Chance); int chance = new Random(Guid.NewGuid().GetHashCode()).Next(0 + target.Chance, config.ChanceThreshold + target.Chance); _log.Debug($"Got range {rangeBase} and chance {chance} for kicking {eventArgs.Data.From.GetNick()} in {eventArgs.Data.Channel}, their configured chance is {target.Chance}"); _log.Debug($"Range for {chance} to fall in is {rangeBase - (target.Chance / 2)}-{rangeBase + (target.Chance / 2)}"); if (chance >= rangeBase - (target.Chance / 2) && chance <= rangeBase + (target.Chance / 2)) { string message = config.MessageList[new Random(Guid.NewGuid().GetHashCode()).Next(0, config.MessageList.Count - 1)]; _log.Info($"Going to kick {eventArgs.Data.From} now"); client.RfcKick(eventArgs.Data.Channel, eventArgs.Data.From.GetNick(), message); } }
private void ProcessChatCommandSeen(IrcClient client, IIrcMessageSource source, IList <IIrcMessageTarget> targets, string command, IList <string> parameters) { if (source is IrcUser) { if (parameters[0].Equals(source.Name, StringComparison.OrdinalIgnoreCase)) { client.LocalUser.SendMessage(targets, "If you're trying to find yourself, might I suggest long hikes in nature and meditation."); } else if (parameters[0].Equals(ConfigSettings.NickName, StringComparison.OrdinalIgnoreCase)) { client.LocalUser.SendMessage(targets, $"I was last seen being asked a stupid question by {source.Name}."); } else if (UsersSeen.ContainsKey(parameters[0])) { UserSeenStatus status = UsersSeen[parameters[0]]; var mostRecentEvent = status.SeenEvents.OrderBy(kvp => kvp.Value.TimeSeen).Last();// .Values.Select(kvp => kvp).Max(kvp => kvp.TimeSeen); client.LocalUser.SendMessage(targets, $"{parameters[0]} was last seen in {mostRecentEvent.Value.Channel} {mostRecentEvent.Key.ToFriendlyString()}" + $" \"{mostRecentEvent.Value.ActivityText}\" on {status.GetActivityTimeString(mostRecentEvent.Key)}"); } else if (parameters[0].Equals("-l", StringComparison.OrdinalIgnoreCase) && UsersSeen.ContainsKey(parameters[1])) { UserSeenStatus status = UsersSeen[parameters[1]]; string action_time = status.GetActivityTimeString(UserSeenStatus.ActivityType.Action); string quit_time = status.GetActivityTimeString(UserSeenStatus.ActivityType.Part); string join_time = status.GetActivityTimeString(UserSeenStatus.ActivityType.Join); string nick_time = status.GetActivityTimeString(UserSeenStatus.ActivityType.NicknameChange); string text_time = status.GetActivityTimeString(UserSeenStatus.ActivityType.Chat); client.LocalUser.SendMessage(targets, $"action_time: {action_time} quit_time: {quit_time} join_time: {join_time} nick_time: {nick_time} text_time: {text_time}"); } else { client.LocalUser.SendMessage(targets, "I see nothing, nothing!"); } } }
public void CommandThreadState(object sender, CommandEventArgs e) { IrcClient client = null; foreach (ClientEntry clientEntry in Bot.Clients) { IrcClient _client = clientEntry.Client; if (_client.Address.Equals(e.Parameters[0], StringComparison.OrdinalIgnoreCase) || (_client.Extensions.NetworkName ?? "").Equals(e.Parameters[0], StringComparison.OrdinalIgnoreCase)) { client = _client; break; } } if (client == null) { e.Reply(string.Format("I'm not connected to \u0002{0}\u0002.", e.Parameters[0])); return; } var method = Bot.GetClientEntry(client).CurrentProcedure; if (method == null) { e.Reply(string.Format("\u0002{0}\u0002's read thread is \u0002standing by\u0002.", e.Parameters[0])); } else { var attribute = method.GetCustomAttributes <CommandAttribute>().FirstOrDefault(); if (attribute != null) { e.Reply(string.Format("\u0002{0}\u0002's read thread is in \u0002{1}\u0002 – !\u0002{2}\u0002.", e.Parameters[0], Bot.GetClientEntry(client).CurrentPlugin.Key, attribute.Names[0])); } else { e.Reply(string.Format("\u0002{0}\u0002's read thread is in \u0002{1}\u0002 – !\u0002{2}\u0002.", e.Parameters[0], Bot.GetClientEntry(client).CurrentPlugin.Key, method.Name)); } } }
public static void Me(IrcClient ircClient, string userName, string message) { #if DEBUG Log.Message("!me for " + userName); #endif if (Names.Any(x => x.EqualsIgnoreCase(userName))) { #if DEBUG Log.Message("Already got that name"); #endif ircClient.SendPublicChatMessage("@" + userName + " : Please be patient you are queued to be spawned"); return; //pending } #if DEBUG Log.Message("Name not queued"); #endif Pawn me = PawnCommand.FindMe(userName); if (me == null) { #if DEBUG Log.Message("Queued"); #endif ircClient.SendPublicChatMessage("@" + userName + " : Added name to the queue"); Names.Add(userName); //queued } else { DoMe(me, ircClient, userName, message); } #if DEBUG Log.Message("!me done"); #endif }
// user@host PRIVMSG BotName :part #channel public static void Part(string mode, Network network, IrcClient client, MessageArgs args) { try { if (!network.Admins.Contains($"{args.Ident.Replace("~", "")}@{args.Host}")) // Check if the user that executed the command is an admin { client.WriteLine($"NOTICE {args.Nick} :You don't have access to this command."); } else { if (args.MessageArray.Length < 2) { client.WriteLine($"NOTICE {args.Nick} :No parting channel specified."); } else if ((args.MessageArray.Length < 3) && (args.MessageArray[1][0] != '#')) { client.WriteLine($"NOTICE {args.Nick} :{args.MessageArray[1]} is not a channel."); } else { string[] channels = client.GetChannels(); if (!channels.Contains(args.MessageArray[1])) { client.WriteLine($"NOTICE {args.Nick} :I am not in that channel."); } else { client.WriteLine($"PART {args.MessageArray[1]}"); } } } } catch (Exception ex) { Logger.ExceptionLogger(ex); } }
public bool RunArenaRegex(IrcClient client, IrcMessageTarget channel, IrcUser sender, string message) { foreach (System.Reflection.MethodInfo method in this.GetType().GetMethods(System.Reflection.BindingFlags.Instance | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic)) { foreach (Attribute attribute in method.GetCustomAttributes(typeof(ArenaRegexAttribute), false)) { foreach (string expression in ((ArenaRegexAttribute)attribute).Expressions) { Match match = Regex.Match(message, expression); if (match.Success) { try { method.Invoke(this, new object[] { this, new TriggerEventArgs(client, channel, sender, match) }); } catch (Exception ex) { this.LogError(method.Name, ex); } return(true); } } } } return(false); }
/// <summary> /// /// </summary> protected override void Cleanup() { // cleanup IRC client if (IrcClient != null) { // detach event handlers IrcClient.Connected -= OnIrcClientConnected; IrcClient.ConnectFailed -= OnIrcClientConnectFailed; IrcClient.Disconnected -= OnIrcClientDisconnected; IrcClient.Registered -= OnIrcClientRegistered; IrcClient.ProtocolError -= OnIrcClientProtocolError; IrcClient.WhoXReplyReceived -= OnWhoXReplyReceived; IrcClient.Disconnect(); IrcClient.Dispose(); IrcClient = null; IrcChannel = null; } RecentAdmins.Clear(); base.Cleanup(); }
/// <summary> /// </summary> /// <param name="client"> /// </param> /// <param name="source"> /// </param> /// <param name="targets"> /// </param> /// <param name="command"> /// </param> /// <param name="parameters"> /// </param> private void ProcessChatCommandLogOut( IrcClient client, IIrcMessageSource source, IList <IIrcMessageTarget> targets, string command, IList <string> parameters) { var sourceUser = (IrcUser)source; CellAoBotUser cellaoBotUser = this.GetCellAOBotUser(sourceUser); if (parameters.Count != 0) { throw new InvalidCommandParametersException(1); } // Log out CellAO user. cellaoBotUser.LogOut(); this.cellAoBotUsers.Remove(cellaoBotUser); IList <IIrcMessageTarget> replyTargets = this.GetDefaultReplyTarget(client, sourceUser, targets); client.LocalUser.SendMessage(replyTargets, "You are now logged out."); }
/// <summary> /// </summary> /// <param name="client"> /// </param> /// <param name="source"> /// </param> /// <param name="targets"> /// </param> /// <param name="command"> /// </param> /// <param name="parameters"> /// </param> private void ProcessChatCommandListUsers( IrcClient client, IIrcMessageSource source, IList <IIrcMessageTarget> targets, string command, IList <string> parameters) { var sourceUser = (IrcUser)source; if (parameters.Count != 0) { throw new InvalidCommandParametersException(1); } // List all currently logged-in twitter users. var replyTargets = GetDefaultReplyTarget(client, sourceUser, targets); foreach (var tu in CharacterDao.Instance.GetLoggedInCharacters()) { client.LocalUser.SendMessage(replyTargets, "Online Characters: {0}", tu.Name); } }
internal Command(IrcClient client, IrcBot bot) { LoadConfig(); _client = client; _ircBot = bot; Type interfaceType = typeof(ICommand); Commands = AppDomain.CurrentDomain.GetAssemblies() .SelectMany(x => x.GetTypes()) .Where(x => interfaceType.IsAssignableFrom(x) && !x.IsInterface && !x.IsAbstract) .Select(Activator.CreateInstance).Cast <ICommand>().OrderByDescending(c => c.Priority); if (Commands == null) { throw new Exception("null commands available"); } foreach (ICommand command in Commands) { _log.Debug($"Found command: {command.CommandName}"); } }
public PdhoBot(BotSettings settings) { _settings = settings; _client = new IrcClient(); _client.Connected += ClientOnConnected; _client.ConnectFailed += ClientOnConnectFailed; _client.Disconnected += ClientOnDisconnected; _client.MotdReceived += ClientOnMotdReceived; _client.Registered += ClientOnRegistered; _reddit = new Reddit(); _redditUser = _reddit.LogIn(_settings.RedditUsername, _settings.RedditPassword); _subreddit = _reddit.GetSubreddit(_settings.Subreddit); _commands = new List <ICommand> { new FlairCommand(), new AuthCommand() }; _auth = new Dictionary <string, string>(); }
private void ProcessChatCommandZoneInfo( IrcClient client, IIrcMessageSource source, IList <IIrcMessageTarget> targets, string command, IList <string> parameters) { int numberOfZoneEnginesConnected = Program.ISCom.ClientCount; List <string> addressList = Program.ISCom.GetZoneEngineIds(); StringBuilder sb = new StringBuilder(); var sourceUser = (IrcUser)source; IList <IIrcMessageTarget> replyTargets = this.GetDefaultReplyTarget(client, sourceUser, targets); client.LocalUser.SendMessage( replyTargets, "{0}", "Number of ZoneEngines connected: " + numberOfZoneEnginesConnected); sb.AppendLine("Number of ZoneEngines connected: " + numberOfZoneEnginesConnected); foreach (string s in addressList) { client.LocalUser.SendMessage(replyTargets, "{0}", s); } }
private void timer1_Tick(object sender, EventArgs e) { if (irc.IsConnected) { /* Nick prot */ if (pub.NProt && irc.Nickname.ToLower() != "power") { irc.RfcWhois("power"); } /* Make sure we're joined to a channel */ if (irc.JoinedChannels.Count == 0) { irc.RfcJoin(InitialChannel); } } else { /* If we were disconnected, then reconnect */ irc = new IrcClient(); Form1_Load(sender, e); } }
public static void Me(IrcClient ircClient, string userName, string message) { userName += " Raider"; if (Names.Any(x => x.EqualsIgnoreCase(userName))) { ircClient.SendPublicChatMessage("@" + userName + " : Please be patient you are queued to be spawned"); return; //pending } Pawn me = PawnCommand.FindMe(userName); if (me == null) { _twitchRaiders++; ircClient.SendPublicChatMessage("@" + userName + " : Added name to the raider queue"); Names.Add(userName); //queued } else { DoRaider(me, ircClient, userName, message); } }
string IPlugin.InvokeWithMessage(string source, string message, ref IrcClient client) { string toSend = null; if (message.StartsWith(".ddg")) { XmlDocument xd = new XmlDocument(); xd.Load(GetDDGApiUrl(message.Split(new char[] { ' ' }, 2)[1])); if (xd.SelectSingleNode("/DuckDuckGoResponse/Answer") != null) { toSend = xd.SelectSingleNode("/DuckDuckGoResponse/Answer").InnerText; } // dear diary, can I have my ?. operator soon? if (xd.SelectSingleNode("/DuckDuckGoResponse/Abstract") != null) { if (!String.IsNullOrWhiteSpace(xd.SelectSingleNode("/DuckDuckGoResponse/Abstract").InnerText)) { toSend = String.Format("{0} - {1}", xd.SelectSingleNode("/DuckDuckGoResponse/Abstract").InnerText, xd.SelectSingleNode("/DuckDuckGoResponse/AbstractURL").InnerText); } } } return(toSend); }
public static void HandleTwitchMessage(IrcClient client, IrcMessage message) { // Check for exactly one occurrence of PRIVMSG/USERNOTICE to help prevent exploiting var isPrivMsg = message.RawMessage.Contains("PRIVMSG") && (message.RawMessage.LastIndexOf("PRIVMSG", StringComparison.Ordinal) == message.RawMessage.IndexOf("PRIVMSG", StringComparison.Ordinal)); var isUserNotice = message.RawMessage.Contains("USERNOTICE") && (message.RawMessage.LastIndexOf("USERNOTICE", StringComparison.Ordinal) == message.RawMessage.IndexOf("USERNOTICE", StringComparison.Ordinal)); if (isUserNotice && !isPrivMsg) { client.OnTwitchResubReceived(new TwitchResubEventArgs(message.RawMessage)); } else if (isPrivMsg) { client.OnTwitchMessageReceived(new TwitchMessageEventArgs(message.RawMessage)); } // If we got here, the message has ambiguous commands and could be suspicious client.OnSuspiciousMessageReceived(new RawMessageEventArgs(message.RawMessage, false)); }
public void RunCommand(IrcClient client, GroupCollection values, IrcEventArgs eventArgs, IrcBot ircBot) { var min = Convert.ToInt32(values[1].Value); var max = Convert.ToInt32(values[2].Value); if (min < 1) { client.SendMessage(SendType.Message, eventArgs.Data.Channel, "Min value too small"); return; } if (max > 2000) { client.SendMessage(SendType.Message, eventArgs.Data.Channel, "Max value is unreasonably large"); return; } List <int> randomValues = new List <int> { min, max }; File.WriteAllText(Path.Join("Config", "ree.json"), JsonConvert.SerializeObject(randomValues)); client.SendMessage(SendType.Message, eventArgs.Data.Channel, $"Modified ree config with {string.Join(", ", randomValues.ToArray())}"); }
public static void HandleKick(IrcClient client, IrcMessage message) { var channel = client.Channels[message.Parameters[0]]; var kicked = channel.Users[message.Parameters[1]]; if (message.Parameters[1] == client.User.Nick) // We've been kicked { client.Channels.Remove(client.Channels[message.Parameters[0]]); } else { if (channel.Users.Contains(message.Parameters[1])) { channel.Users.Remove(message.Parameters[1]); } foreach (var mode in channel.UsersByMode.Where(mode => mode.Value.Contains(message.Parameters[1]))) { mode.Value.Remove(message.Parameters[1]); } } client.OnUserKicked(new KickEventArgs(channel, new IrcUser(message.Prefix), kicked, message.Parameters[2])); }
private void CheckChannels() { this.ArenaConnection = null; this.ArenaChannel = null; foreach (string channel in this.Channels) { string[] fields = channel.Split(new char[] { '/' }, 2); if (fields.Length == 1) { fields = new string[] { null, fields[0] } } ; if (fields[1] == "*") { continue; } foreach (ClientEntry clientEntry in Bot.Clients) { IrcClient client = clientEntry.Client; if (client.Address == "!Console") { continue; } if (fields[0] == null || fields[0] == "*" || fields[0].Equals(clientEntry.Name, StringComparison.InvariantCultureIgnoreCase) || fields[0].Equals(clientEntry.Address, StringComparison.InvariantCultureIgnoreCase)) { if (client.Channels.Contains(fields[1])) { this.ArenaConnection = client; this.ArenaChannel = fields[1]; return; } } } } }
public override void Leave() { if (ircClient != null) { TryIrc(() => { ircClient.Disconnected -= ircClient_Disconnected; ircClient.RawMessageReceived -= ircClient_RawMessageReceived; }); } if (disconnectTimer != null) { disconnectTimer.Change(Timeout.Infinite, Timeout.Infinite); } if (pingTimer != null) { pingTimer.Change(Timeout.Infinite, Timeout.Infinite); } if (statsPoller != null) { statsPoller.Stop(); } Log.WriteInfo("Twitch leaving {0}", ChannelName); TryIrc(() => ircClient.Quit("bye!")); TryIrc(() => ircClient.Dispose()); ircClient = null; if (LeaveCallback != null) { LeaveCallback(this); } }
public static void HandleWhoEnd(IrcClient client, IrcMessage message) { if (client.ServerInfo.ExtendedWho) { var query = client.RequestManager.PendingOperations.Where(kvp => kvp.Key.StartsWith("WHO " + message.Parameters[1])).FirstOrDefault(); var request = client.RequestManager.DequeueOperation(query.Key); var whoxList = (List <ExtendedWho>)request.State; foreach (var whox in whoxList) { if (!client.Users.Contains(whox.User.Nick)) { client.Users.Add(whox.User); } } request.Callback?.Invoke(request); client.OnWhoxReceived(new Events.WhoxReceivedEventArgs(whoxList.ToArray())); } else { var query = client.RequestManager.PendingOperations.Where(kvp => kvp.Key == "WHO " + message.Parameters[1]).FirstOrDefault(); var request = client.RequestManager.DequeueOperation(query.Key); var whoList = (List <ExtendedWho>)request.State; foreach (var who in whoList) { if (!client.Users.Contains(who.User.Nick)) { client.Users.Add(who.User); } } request.Callback?.Invoke(request); client.OnWhoxReceived(new Events.WhoxReceivedEventArgs(whoList.ToArray())); } }
private static void DoRaider(Pawn me, IrcClient ircClient, string userName, string cmd) { var message = new StringBuilder("@" + userName + " : "); var command = cmd?.Substring(5)?.Trim()?.ToLower(); if (!command.NullOrEmpty()) { if (PawnCommand.CommonPawnCommands(me, command, message)) { } else if (command.StartsWith(MeCommands.help.ToString())) { if (helpText == null) { helpText = DefDatabase <HediffDef> .GetNamedSilentFail("rimtwitch_explain_raid"); } //Help Text message.Append(helpText.description); } else if (command.StartsWith(RaidCommands.escape.ToString())) { Escape(me, message); } else { message.Append("Sorry, What?"); } } else { message.Append("Status: ").Append(me.Summarize()); } ircClient.SendPublicChatMessage(message.ToString()); }
public IRCBot() { mainIRCClient = new IrcClient(); Thread.CurrentThread.Name = "Main"; //Making some unkickability mainIRCClient.AutoRelogin = true; // UTF-8 test mainIRCClient.Encoding = System.Text.Encoding.UTF8; // wait time between messages, we can set this lower on own irc servers mainIRCClient.SendDelay = 200; // we use channel sync, means we can use irc.GetChannel() and so on mainIRCClient.ActiveChannelSyncing = true; // here we connect the events of the API to our written methods // most have own event handler types, because they ship different data mainIRCClient.OnQueryMessage += new IrcEventHandler(OnQueryMessage); mainIRCClient.OnError += new ErrorEventHandler(OnError); mainIRCClient.OnRawMessage += new IrcEventHandler(OnRawMessage); }
public static void HandlePrivmsg(IrcClient client, IrcMessage message) { var eventArgs = new PrivateMessageEventArgs(message); client.OnPrivateMessageRecieved(eventArgs); if (eventArgs.PrivateMessage.IsChannelMessage) { try { // Populate this user's hostname and user from the message // TODO: Merge all users from all channels into one list and keep references to which channels they're in var channel = client.Channels[eventArgs.PrivateMessage.Source]; var u = channel.Users[eventArgs.PrivateMessage.User.Nick]; u.Hostname = eventArgs.PrivateMessage.User.Hostname; u.User = eventArgs.PrivateMessage.User.User; } catch { /* silently ignored */ } client.OnChannelMessageRecieved(eventArgs); } else { client.OnUserMessageRecieved(eventArgs); } }
public void Execute(IrcClient Client, string channel, IrcUser Sender, string message) { message = message.Trim(); if (message == "") { Client.LocalUser.SendMessage(channel, horoscopeHelpMsg()); } else { if (!signs.ContainsKey(message)) { Client.LocalUser.SendMessage(channel, "Why won't you give me a sign~"); return; } string html = getHTML(signs[message]); string horoscope = dropHtmlPrecedingHoroscope(html, message); horoscope = dropHtmlTailingHoroscope(horoscope); horoscope = html2Txt(horoscope); Client.LocalUser.SendMessage(channel, horoscope); } }
/// <summary> /// Called when a user is deopped in the channel /// </summary> /// <param name="deop">DeopEventArgs</param> public void CheckDeop(DeopEventArgs deop) { IrcClient irc = deop.Data.Irc; if (deop.Who != irc.Nickname) { if (deop.Whom == irc.Nickname) { irc.RfcNotice(deop.Who, "Op me back LaMeR!"); } else { /* Check prot */ IrcUser usr = irc.GetIrcUser(deop.Whom); if (usr != null) { if (ops.GetProtLevel(usr.Ident + "@" + usr.Host) >= 100) { irc.Op(deop.Channel, deop.Whom); } } } } }