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