public void Kill(WinterBot bot, TwitchUser user, string cmd, string value)
{
bot.WriteDiagnostic(DiagnosticFacility.Info, "Bot killed by streamer.");
WinterBotSource.Log.Kill();
bot.Shutdown();
}
private void CheckModeratorStatus(IrcChannelUser chanUser)
{
string username = chanUser.User.NickName;
bool op = chanUser.Modes.Contains('o');
TwitchUser user = m_data.GetUser(username, op);
if (user != null)
{
if (op)
{
if (!m_mods.Contains(user))
{
OnInformModerator(user, true);
m_mods.Add(user);
}
}
else
{
if (m_mods.Contains(user))
{
OnInformModerator(user, false);
m_mods.Remove(user);
}
}
}
}
public ChatMessage(DateTime time, TwitchUser user, Action action, string text = null)
{
m_time = time;
m_user = user;
m_text = text;
m_action = action;
}
private bool CheckAndTimeoutSpam(WinterBot bot, TwitchUser user, string text)
{
if (user.IsSubscriber)
{
return(false);
}
if (String.IsNullOrWhiteSpace(m_clearMsg))
{
return(false);
}
if (text.ToLower().Contains(m_clearMsg))
{
if (m_spamTimeout == null)
{
bot.Ban(user);
}
else
{
bot.Timeout(user, (int)m_spamTimeout);
}
return(true);
}
return(false);
}
public void RemoveCommand(WinterBot sender, TwitchUser user, string c, string a)
{
if (!m_options.UserCommandsEnabled)
{
return;
}
Args args = a.ParseArguments(m_bot);
string cmd = args.GetOneWord();
if (cmd == null)
{
sender.SendResponse(Importance.Med, m_removeCommandUsage);
return;
}
if (cmd[0] == '!')
{
cmd = cmd.Substring(1);
}
cmd = cmd.ToLower();
if (m_commands.ContainsKey(cmd))
{
m_commands.Remove(cmd);
}
else
{
sender.SendResponse(Importance.Med, string.Format("Command {0} not found.", cmd));
}
}
public void AutoMessageMode(WinterBot sender, TwitchUser user, string cmd, string value)
{
bool shouldEnable = false;
if (value.Trim().ParseBool(ref shouldEnable))
{
m_msgOptions.Enabled = shouldEnable;
if (shouldEnable)
{
if (ShouldEnable)
{
Enable();
}
else
{
Disable();
}
}
sender.SendResponse(Importance.Med, "Auto message now {0}.", shouldEnable ? "enabled" : "disabled");
}
else
{
sender.SendResponse(Importance.Med, "Auto message is currently {0}.", m_msgOptions.Enabled ? "enabled" : "disabled");
}
}
internal void AddRegular(TwitchUser user)
{
if (m_regulars != null)
{
m_regulars.Add(user);
}
}
void bot_MessageReceived(WinterBot sender, TwitchUser user, string text)
{
if (m_lastStop.Elapsed().TotalSeconds < m_options.VoteClearTimer)
return;
if (m_active && m_lastVote.Elapsed().TotalSeconds >= m_options.VoteTimeout)
Reset(sender);
int result = -1;
for (int i = 1; i <= m_options.MaxVoteValue; ++i)
{
if (text.Contains(i.ToString()))
{
if (result != -1)
{
result = -1;
break;
}
result = i;
}
}
if (result != -1)
{
m_result[user] = result;
m_lastVote = DateTime.Now;
m_dirty = true;
if (!m_active)
{
m_lastMessage = DateTime.Now;
m_active = true;
}
}
}
public void Kill(WinterBot bot, TwitchUser user, string cmd, string value)
{
bot.WriteDiagnostic(DiagnosticFacility.Info, "Bot killed by streamer.");
WinterBotSource.Log.Kill();
bot.Shutdown();
}
internal void RemoveRegular(TwitchUser user)
{
if (m_regulars != null)
{
m_regulars.Remove(user);
}
}
public void Deny(WinterBot sender, TwitchUser user, string cmd, string value)
{
value = value.Trim();
if (!TwitchUsers.IsValidUserName(value))
{
sender.SendResponse(Importance.Med, "{0}: Usage: !deny [user]", user.Name);
return;
}
var target = sender.Users.GetUser(value);
if (target.IsModerator)
{
return;
}
if (m_permit.Contains(target))
{
m_permit.Remove(target);
}
m_denyList.Add(target);
sender.SendResponse(Importance.High, "{0}: {1} is no longer allowed to post links.", user.Name, target.Name);
}
public void JukeBoxCommand(WinterBot sender, TwitchUser user, string cmd, string value)
{
if (!m_enabled)
{
if (!sender.CanUseCommand(user, AccessLevel.Mod))
{
if (m_lastMessage.Elapsed().TotalSeconds <= 30)
return;
m_lastMessage = DateTime.Now;
sender.SendResponse(Importance.Low, "The jukebox is CLOSED. No additional requests are being accepted.");
return;
}
value = value.Trim().ToLower();
if (value == "on")
{
m_enabled = true;
m_lastMessage = DateTime.Now;
sender.SendResponse(Importance.Med, "Jukebox activated. Use '!JukeboxMode off' to deactivate.");
}
else if (value == "off")
{
sender.SendResponse(Importance.Med, "Jukebox mode is off.");
}
else
{
sender.SendResponse(Importance.Low, "Usage: '!jukebox on' and '!jukebox off'. Mod only.");
}
}
else
{
if (sender.CanUseCommand(user, AccessLevel.Mod))
{
if (value == "on")
{
sender.SendResponse(Importance.Low, "Jukebox mode is already enabled.");
}
else if (value == "off")
{
sender.SendResponse(Importance.High, "The jukebox is shutting down for the night. Please hold your song requests for next time.");
m_enabled = false;
}
else
{
SendMessage(sender);
}
}
else
{
if (m_lastMessage.Elapsed().TotalSeconds <= 10)
return;
m_lastMessage = DateTime.Now;
SendMessage(sender);
}
}
}
private void ChatActionReceived(TwitchClient source, TwitchUser user, string text)
{
if (ActionReceived != null)
{
m_events.Enqueue(new ActionEvent(user, text));
m_event.Set();
}
}
private void ClearChatHandler(TwitchClient source, TwitchUser user)
{
if (ChatClear != null)
{
m_events.Enqueue(new ClearEvent(user));
m_event.Set();
}
}
private void ChatMessageReceived(TwitchClient source, TwitchUser user, string text)
{
if (MessageReceived != null)
{
m_events.Enqueue(new MessageEvent(user, text));
m_event.Set();
}
}
private void SubscribeHandler(TwitchClient source, TwitchUser user)
{
if (UserSubscribed != null)
{
m_events.Enqueue(new SubscribeEvent(user));
m_event.Set();
}
}
private void OnUnknownCommand(TwitchUser user, string cmd, string value)
{
var evt = UnknownCommandReceived;
if (evt != null)
{
evt(this, user, cmd, value);
}
}
public void ClearChat(TwitchUser user)
{
if (Passive)
{
return;
}
Timeout(user, 1);
}
protected void OnUserSubscribed(TwitchUser user)
{
var subscribed = UserSubscribed;
if (subscribed != null)
{
subscribed(this, user);
}
}
public void Banliust(WinterBot sender, TwitchUser user, string cmd, string value)
{
if (string.IsNullOrWhiteSpace(value))
return;
UrlMatch match = new UrlMatch(sender, value);
m_urlBanlist.Add(match);
sender.SendResponse(Importance.Med, "Added {0} to the url ban list.", value);
}
private void bot_UserFollowed(WinterBot sender, TwitchUser user)
{
var msg = m_chatOptions.FollowMessage;
if (!string.IsNullOrWhiteSpace(msg))
{
sender.SendMessage(Importance.Low, "{0}: {1}", user.Name, msg);
}
}
void bot_UserSubscribed(WinterBot sender, TwitchUser user)
{
var subMessage = m_chatOptions.SubscribeMessage;
if (!string.IsNullOrWhiteSpace(subMessage))
{
sender.SendMessage(Importance.High, "{0}: {1}", user.Name, subMessage);
}
}
protected void OnInformModerator(TwitchUser user, bool moderator)
{
var evt = InformModerator;
if (evt != null)
{
evt(this, user, moderator);
}
}
protected void OnInformSubscriber(TwitchUser user)
{
var evt = InformSubscriber;
if (evt != null)
{
evt(this, user);
}
}
void InformModerator(TwitchClient sender, TwitchUser user, bool moderator)
{
var evt = moderator ? ModeratorAdded : ModeratorRemoved;
if (evt != null)
{
m_events.Enqueue(new ModEvent(user, moderator));
m_event.Set();
}
}
public void AddCommand(WinterBot sender, TwitchUser user, string c, string v)
{
if (!m_options.UserCommandsEnabled)
{
return;
}
Args args = v.ParseArguments(m_bot);
AccessLevel level = args.GetAccessFlag("ul", AccessLevel.Mod);
string cmdName = args.GetOneWord();
string cmdText = args.GetString();
if (string.IsNullOrWhiteSpace(cmdName) || string.IsNullOrWhiteSpace(cmdText) || args.Error != null)
{
sender.SendResponse(Importance.Med, m_addCommandUsage);
return;
}
if (cmdName[0] != '!')
{
sender.SendResponse(Importance.Med, string.Format("User commands must start with a '!'. {0}", m_addCommandUsage));
return;
}
else
{
cmdName = cmdName.Substring(1);
}
if (cmdText[0] == '.' || cmdText[0] == '/')
{
sender.SendResponse(Importance.Med, string.Format("Cannot create a command which starts with a '{0}'.", cmdText[0]));
return;
}
UserCommand userCommand = new UserCommand();
userCommand.Value = cmdText;
userCommand.AccessRequired = level;
userCommand.Command = cmdName;
cmdName = cmdName.ToLower();
bool exists = m_commands.ContainsKey(cmdName);
m_commands[cmdName] = userCommand;
if (exists)
{
sender.SendResponse(Importance.Med, string.Format("Updated command: !{0}.", cmdName));
}
else
{
sender.SendResponse(Importance.Med, string.Format("Successfully added command: !{0}.", cmdName));
}
}
//[BotCommand(AccessLevel.Normal, "insult")]
public void InsultUser(WinterBot sender, TwitchUser user, string cmd, string value)
{
value = value.Trim().ToLower();
if (TwitchUsers.IsValidUserName(value))
user = sender.Users.GetUser(value);
if (m_last.Elapsed().Minutes >= 1)
sender.SendMessage("{0}, {1}", user.Name, m_insults[m_random.Next(m_insults.Length)]);
m_last = DateTime.Now;
}
private bool MessageTooLong(TwitchUser user, string text)
{
int max = m_lengthOptions.GetMaxLength(user);
if (max <= 0)
{
return(false);
}
return(text.Length > max);
}
public void Banliust(WinterBot sender, TwitchUser user, string cmd, string value)
{
if (string.IsNullOrWhiteSpace(value))
{
return;
}
UrlMatch match = new UrlMatch(sender, value);
m_urlBanlist.Add(match);
sender.SendResponse(Importance.Med, "Added {0} to the url ban list.", value);
}
public void ListCommands(WinterBot sender, TwitchUser user, string cmd, string value)
{
if (!m_options.UserCommandsEnabled)
{
return;
}
int delay = m_options.UserCommandDelay;
//if (m_lastMessage.Elapsed().TotalSeconds < delay || m_lastCommand.Elapsed().TotalSeconds < delay)
// return;
Args args = value.ParseArguments(m_bot);
AccessLevel level = args.GetAccessFlag("ul", user.Access);
string part;
switch (level)
{
case AccessLevel.Streamer:
part = "streamer";
break;
case AccessLevel.Mod:
part = "moderators";
break;
case AccessLevel.Normal:
part = "anyone";
break;
case AccessLevel.Regular:
part = "regulars";
break;
case AccessLevel.Subscriber:
part = "subscribers";
break;
default:
return;
}
string[] cmds = (from c in m_commands.Values where c.AccessRequired <= level orderby c.Command select c.Command).ToArray();
if (cmds.Length == 0)
{
sender.SendResponse(Importance.Low, "No commands available.", part);
}
else
{
sender.SendResponse(Importance.Low, "Commands {0} can use: {1}", part, string.Join(", ", cmds));
}
}
public void AddCommand(WinterBot sender, TwitchUser user, string c, string v)
{
Args args = v.ParseArguments(m_bot);
AccessLevel level = args.GetAccessFlag("ul", AccessLevel.Mod);
string cmdName = args.GetOneWord();
string cmdText = args.GetString();
if (string.IsNullOrWhiteSpace(cmdName) || string.IsNullOrWhiteSpace(cmdText) || args.Error != null)
{
sender.SendResponse(Importance.Med, m_addCommandUsage);
return;
}
if (cmdName[0] != '!')
{
sender.SendResponse(Importance.Med, string.Format("User commands must start with a '!'. {0}", m_addCommandUsage));
return;
}
else
{
cmdName = cmdName.Substring(1);
}
if (cmdText[0] == '.' || cmdText[0] == '/')
{
sender.SendResponse(Importance.Med, string.Format("Cannot create a command which starts with a '{0}'.", cmdText[0]));
return;
}
cmdName = cmdName.ToLower();
Command userCommand = new Command(level, cmdText);
bool exists;
lock (m_sync)
{
exists = m_commands.ContainsKey(cmdName);
m_commands[cmdName] = userCommand;
m_dirty = true;
}
if (exists)
{
sender.SendResponse(Importance.Med, string.Format("Updated command: !{0}.", cmdName));
WinterBotSource.Log.AddCommand(user.Name, cmdName, cmdText);
}
else
{
sender.SendResponse(Importance.Med, string.Format("Successfully added command: !{0}.", cmdName));
WinterBotSource.Log.UpdateCommand(user.Name, cmdName, cmdText);
}
}
private bool TooManyEmotes(TwitchUser user, string message)
{
int max = m_emoteOptions.GetMax(user);
var imgSet = TwitchHttp.Instance.ImageSet;
if (imgSet == null)
{
return(false);
}
return(imgSet.TooManySymbols(message, max, user.IconSet));
}
void bot_MessageReceived(WinterBot sender, TwitchUser user, string text)
{
if (!user.Name.Equals("frostysc", StringComparison.CurrentCultureIgnoreCase))
return;
if (m_random.Next(200) != 7)
return;
if (m_last.Elapsed().Minutes >= 5)
sender.SendMessage("{0}, {1}", user.Name, m_insults[m_random.Next(m_insults.Length)]);
m_last = DateTime.Now;
}
private void SetRegular(WinterBot sender, string cmd, string value, bool regular)
{
value = value.Trim();
if (!TwitchUsers.IsValidUserName(value))
{
sender.WriteDiagnostic(DiagnosticFacility.UserError, "{0}: Invalid username '{1}.", cmd, value);
return;
}
TwitchUser target = sender.Users.GetUser(value);
target.IsRegular = regular;
sender.SendResponse(Importance.Med, "{0} {1} the regular list.", target.Name, regular ? "added to " : "removed from");
}
public T GetValue(TwitchUser user)
{
if (user.IsSubscriber)
{
return(m_sub);
}
if (user.IsRegular)
{
return(m_reg);
}
return(m_all);
}
public TwitchUser GetUser(string username, bool create = true)
{
username = username.ToLower();
TwitchUser user;
lock (m_sync)
{
if (!m_users.TryGetValue(username, out user) && create)
{
user = new TwitchUser(this, username);
m_users[username] = user;
}
}
return(user);
}
public void Ban(TwitchUser user)
{
if (Passive)
{
return;
}
var evt = UserBanned;
if (evt != null)
{
evt(this, user);
}
m_twitch.Ban(user.Name);
}
public void Timeout(TwitchUser user, int duration = 600)
{
if (Passive)
{
return;
}
var evt = UserTimedOut;
if (evt != null)
{
evt(this, user, duration);
}
m_twitch.Timeout(user.Name, duration);
}
public void CheckMessage(WinterBot bot, TwitchUser user, string text)
{
if (user.IsModerator)
return;
string clearReason = null;
List<string> urls;
if (HasUrls(text, out urls))
{
// Check bans.
if (MatchesAny(urls, m_urlBanlist))
{
m_winterBot.Ban(user);
if (!string.IsNullOrEmpty(m_urlOptions.BanMessage))
bot.TimeoutMessage("{0}: {1}", user.Name, m_urlOptions.BanMessage);
m_winterBot.WriteDiagnostic(DiagnosticFacility.Ban, "Banned {0} for {1}.", user.Name, string.Join(", ", urls));
}
else if ((m_urlOptions.ShouldEnforce(user) || m_denyList.Contains(user)) && (!MatchesAll(urls, m_urlWhitelist) || MatchesAny(urls, m_urlBlacklist)))
{
if (m_permit.Contains(user))
m_permit.Remove(user);
else
clearReason = m_urlOptions.Message;
}
}
else if (m_symbolOptions.ShouldEnforce(user) && HasSpecialCharacter(text))
{
clearReason = m_symbolOptions.Message;
}
else if (m_capsOptions.ShouldEnforce(user) && TooManyCaps(user, text))
{
clearReason = m_capsOptions.Message;
}
else if (m_emoteOptions.ShouldEnforce(user) && TooManyEmotes(user, text))
{
clearReason = m_emoteOptions.Message;
}
else if (m_lengthOptions.ShouldEnforce(user) && MessageTooLong(user, text))
{
clearReason = m_lengthOptions.Message;
}
if (clearReason != null)
ClearChat(bot, user, clearReason);
}
public void Deny(WinterBot sender, TwitchUser user, string cmd, string value)
{
value = value.Trim();
if (!TwitchUsers.IsValidUserName(value))
{
sender.SendResponse(Importance.Med, "{0}: Usage: !deny [user]", user.Name);
return;
}
var target = sender.Users.GetUser(value);
if (target.IsModerator)
return;
if (m_permit.Contains(target))
m_permit.Remove(target);
m_denyList.Add(target);
sender.SendResponse(Importance.High, "{0}: {1} is no longer allowed to post links.", user.Name, target.Name);
}
public void AutoMessageMode(WinterBot sender, TwitchUser user, string cmd, string value)
{
bool shouldEnable = false;
if (value.Trim().ParseBool(ref shouldEnable))
{
m_msgOptions.Enabled = shouldEnable;
if (shouldEnable)
{
if (ShouldEnable)
Enable();
else
Disable();
}
sender.SendResponse(Importance.Med, "Auto message now {0}.", shouldEnable ? "enabled" : "disabled");
}
else
{
sender.SendResponse(Importance.Med, "Auto message is currently {0}.", m_msgOptions.Enabled ? "enabled" : "disabled");
}
}
void bot_ChatClear(WinterBot sender, TwitchUser user)
{
lock (m_sync)
m_messages.Add(new ChatMessage(DateTime.Now, user, Action.Clear));
}
private void TryProcessCommand(WinterBot sender, TwitchUser user, string text)
{
Debug.Assert(sender == this);
string cmd, value;
if (!TryReadCommand(text, out cmd, out value))
return;
Debug.Assert(cmd != null);
Debug.Assert(value != null);
cmd = cmd.ToLower();
CmdValue command;
if (m_commands.TryGetValue(cmd, out command))
{
if (!CanUseCommand(user, command.Access))
return;
command.Command(this, user, cmd, value);
}
else
{
OnUnknownCommand(user, cmd, value);
}
}
private void SubscribeHandler(TwitchClient source, TwitchUser user)
{
var evt = UserSubscribed;
if (evt != null)
{
m_events.Enqueue(new Tuple<Delegate, object[]>(evt, new object[] { this, user }));
m_event.Set();
}
}
private void OnUnknownCommand(TwitchUser user, string cmd, string value)
{
var evt = UnknownCommandReceived;
if (evt != null)
evt(this, user, cmd, value);
}
void InformModerator(TwitchClient sender, TwitchUser user, bool moderator)
{
var evt = moderator ? ModeratorAdded : ModeratorRemoved;
if (evt != null)
{
m_events.Enqueue(new Tuple<Delegate, object[]>(evt, new object[] { this, user }));
m_event.Set();
}
}
private void SubscribeHandler(TwitchClient sender, TwitchUser user)
{
if (PlaySounds)
m_subSound.Play();
Dispatcher.BeginInvoke(DispatcherPriority.Normal, new Action<TwitchUser>(DispatcherUserSubscribed), user);
}
void bot_UserTimedOut(WinterBot sender, TwitchUser user, int duration)
{
lock (m_sync)
m_messages.Add(new ChatMessage(DateTime.Now, user, Action.Timeout, string.Format("BOT TIMEOUT FOR {0} SECONDS", duration)));
}
internal void RemoveRegular(TwitchUser user)
{
if (m_regulars != null)
m_regulars.Remove(user);
}
internal bool IsRegular(TwitchUser user)
{
return m_regulars != null ? m_regulars.Contains(user) : false;
}
internal void AddRegular(TwitchUser user)
{
if (m_regulars != null)
m_regulars.Add(user);
}
public void ClearChat(TwitchUser user)
{
if (Passive)
return;
Timeout(user, 1);
}
public bool CanUseCommand(TwitchUser user, AccessLevel required)
{
bool isStreamer = m_channel.Equals(user.Name, StringComparison.CurrentCultureIgnoreCase);
switch (required)
{
case AccessLevel.Normal:
return true;
case AccessLevel.Mod:
return isStreamer || user.IsModerator;
case AccessLevel.Subscriber:
return isStreamer || user.IsSubscriber || user.IsModerator;
case AccessLevel.Regular:
return isStreamer || user.IsSubscriber || user.IsModerator || user.IsRegular;
case AccessLevel.Streamer:
return isStreamer;
default:
return false;
}
}
public void Ban(TwitchUser user)
{
if (Passive)
return;
var evt = UserBanned;
if (evt != null)
evt(this, user);
m_twitch.Ban(user.Name);
}
void bot_MessageReceived(WinterBot sender, TwitchUser user, string text)
{
lock (m_sync)
m_messages.Add(new ChatMessage(DateTime.Now, user, Action.Chat, text));
}
private void ChatMessageReceived(TwitchClient source, TwitchUser user, string text)
{
var evt = MessageReceived;
if (evt != null)
{
m_events.Enqueue(new Tuple<Delegate, object[]>(evt, new object[] { this, user, text }));
m_event.Set();
}
}
void bot_UserSubscribed(WinterBot sender, TwitchUser user)
{
lock (m_sync)
m_messages.Add(new ChatMessage(DateTime.Now, user, Action.Subbed));
}
private void ClearChatHandler(TwitchClient source, TwitchUser user)
{
var evt = ChatClear;
if (evt != null)
{
m_events.Enqueue(new Tuple<Delegate, object[]>(evt, new object[] { this, user }));
m_event.Set();
}
}
public void Timeout(TwitchUser user, int duration = 600)
{
if (Passive)
return;
var evt = UserTimedOut;
if (evt != null)
evt(this, user, duration);
m_twitch.Timeout(user.Name, duration);
}
private void DispatcherUserSubscribed(TwitchUser user)
{
AddItem(new Subscriber(this, user));
}
