public void RemoveCommand(WinterBot sender, TwitchUser user, string c, string a)
{
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);
}
lock (m_sync)
{
cmd = cmd.ToLower();
if (m_commands.ContainsKey(cmd))
{
m_commands.Remove(cmd);
m_remove.Add(cmd);
m_dirty = true;
sender.SendResponse(Importance.Low, string.Format("Removed command {0}.", cmd));
WinterBotSource.Log.RemoveCommand(user.Name, cmd);
}
else
{
sender.SendResponse(Importance.Med, string.Format("Command {0} not found.", cmd));
}
}
}
void bot_Tick(WinterBot sender, TimeSpan timeSinceLastUpdate)
{
if (m_enabled)
{
if (!sender.IsStreamLive)
{
if (!m_streamDead)
{
m_streamDead = true;
m_lastOffline = DateTime.Now;
}
else if (m_lastOffline.Elapsed().TotalMinutes >= 10)
{
m_enabled = false;
m_streamDead = false;
sender.SendResponse(Importance.Med, "Disabling jukebox mode.");
}
}
else
{
m_streamDead = false;
}
}
if (m_enabled && m_lastMessage.Elapsed().TotalMinutes >= 7)
{
SendMessage(sender);
}
}
public BettingSystem(WinterBot bot, WinterOptions options)
{
m_options = options;
m_bot = bot;
Enabled = true;
m_http = new HttpManager(options);
m_http.GetAsync("points.php", LoadPoints);
}
public ViewerCountLogger(WinterBot bot, WinterOptions options)
: base(bot)
{
m_bot = bot;
m_options = options;
m_http = new HttpManager(options);
bot.ViewerCountChanged += bot_ViewerCountChanged;
}
public void Bet(WinterBot sender, TwitchUser user, string cmd, string value)
{
if (!Enabled)
{
return;
}
if (!IsBettingOpen)
{
SendMessage(sender, "{0}: Betting is not currently open.", user.Name);
return;
}
const int min = 1;
const int max = 500;
Args args = value.ToLower().ParseArguments(sender);
string who;
int amount;
if (args.GetInt(out amount))
{
who = args.GetOneWord();
}
else
{
args.Reset();
who = args.GetOneWord();
amount = args.GetInt();
}
if (args.Error != null || string.IsNullOrWhiteSpace(who) || !m_betting.Contains(who))
{
return;
}
if (amount < min)
{
amount = min;
}
else if (amount > max)
{
amount = max;
}
m_bets[user] = new Tuple <string, int>(who, amount);
if (m_thread == null)
{
m_thread = new Thread(SaveProc);
m_thread.Start();
m_bot.BeginShutdown += m_bot_BeginShutdown;
m_bot.EndShutdown += m_bot_EndShutdown;
}
}
private void SendMessage(WinterBot sender, string fmt, params object[] args)
{
if (m_lastMessage.Elapsed().Seconds < 20)
{
return;
}
sender.SendMessage(Importance.Low, string.Format(fmt, args));
m_lastMessage = DateTime.Now;
}
public static void Init(WinterBot bot)
{
WinterOptions options = new WinterOptions(bot.Options);
bot.AddCommands(new JukeBox(bot, options));
bot.AddCommands(new BettingSystem(bot, options));
bot.AddCommands(new ViewerCountLogger(bot, options));
new ChatSaver(bot, options);
bot.AddCommands(new BetterCommands(bot, options));
}
public void ListCommands(WinterBot sender, TwitchUser user, string cmd, string value)
{
if (m_lastCommandList.Elapsed().TotalSeconds < 15)
{
WinterBotSource.Log.DenyCommand(user.Name, cmd, "time");
return;
}
m_lastCommandList = DateTime.Now;
sender.SendMessage("A full listing of user commands can be found here: " + m_http.GetUrl("commands.php"));
m_sent.AddLast(new Tuple <string, DateTime>("commands", DateTime.Now));
}
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);
}
}
public void BettingEnable(WinterBot sender, TwitchUser user, string cmd, string value)
{
bool enable = false;
if (!value.ParseBool(ref enable))
{
sender.SendMessage(Importance.Low, "Betting is currently: {0}", Enabled ? "enabled" : "disabled");
return;
}
Enabled = enable;
sender.SendMessage(Importance.Med, "Betting is now {0}.", Enabled ? "enabled" : "disabled");
}
public ChatSaver(WinterBot bot, WinterOptions options)
: base(bot)
{
m_options = options;
m_bot = bot;
m_http = new HttpManager(options);
bot.MessageReceived += bot_MessageReceived;
bot.ActionReceived += bot_ActionReceived;
bot.UserSubscribed += bot_UserSubscribed;
bot.ChatClear += bot_ChatClear;
bot.UserBanned += bot_UserBanned;
bot.UserTimedOut += bot_UserTimedOut;
}
public BetterCommands(WinterBot bot, WinterOptions options)
: base(bot)
{
if (bot.Options.ChatOptions.UserCommandsEnabled)
{
return;
}
m_bot = bot;
m_options = options;
m_bot.UnknownCommandReceived += UnknownCommandReceived;
m_http = new HttpManager(options);
m_http.GetAsync("api.php", "GETCMDS=1", Load);
}
public void CancelBet(WinterBot sender, TwitchUser user, string cmd, string value)
{
if (!Enabled)
{
return;
}
if (IsBettingClosed)
{
return;
}
ClearBetting();
CancelCallback();
}
void m_bot_Tick(WinterBot sender, TimeSpan timeSinceLastUpdate)
{
if (!IsBettingOpen)
{
sender.SendMessage(Importance.High, "Betting is now CLOSED.");
CancelCallback();
return;
}
if (m_bettingStarted.Elapsed().TotalSeconds >= m_time)
{
sender.SendMessage(Importance.High, "Betting is now CLOSED.");
CancelCallback();
m_state = State.WaitingResult;
}
}
public void OpenBetting(WinterBot sender, TwitchUser user, string cmd, string value)
{
if (!Enabled)
{
return;
}
if (IsBettingOpen || WaitingResult)
{
sender.SendResponse(Importance.Low, "Betting is currently ongoing. Use !result to award points, use !cancelbet to cancel the current bet.");
return;
}
HashSet <string> betting = new HashSet <string>();
Args args = value.ToLower().ParseArguments(sender);
int time = args.GetIntFlag("time", 120, false);
string val;
while ((val = args.GetOneWord()) != null)
{
betting.Add(val);
}
if (betting.Count < 2)
{
sender.SendResponse(Importance.High, "Need at least two people to bet on!");
return;
}
m_betting = betting;
m_bets = new Dictionary <TwitchUser, Tuple <string, int> >();
m_state = State.Open;
m_time = time;
m_bettingStarted = DateTime.Now;
GetCallback();
sender.SendResponse(Importance.High, "Betting is now OPEN. Use '!bet [player] [amount]' to bet. Minimum bet is 1, maximum bet is 500. You start with 3000 points, you can bet even if you have no points.");
}
void UnknownCommandReceived(WinterBot sender, TwitchUser user, string cmd, string value)
{
cmd = cmd.ToLower();
Command command;
lock (m_sync)
if (!m_commands.TryGetValue(cmd, out command))
{
return;
}
if (!sender.CanUseCommand(user, command.AccessLevel))
{
WinterBotSource.Log.DenyCommand(user.Name, cmd, "access");
return;
}
if (CanSendCommand(user, cmd))
{
sender.SendResponse(Importance.Low, command.Text);
m_sent.AddLast(new Tuple <string, DateTime>(cmd, DateTime.Now));
}
}
private void SendMessage(WinterBot bot)
{
m_lastMessage = DateTime.Now;
bot.SendResponse(Importance.Low, m_message);
}
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);
}
}
}
public void Initialize()
{
m_bot = new WinterBot(new Options(), "testdata", "username", "oauth:123");
}
public void Result(WinterBot sender, TwitchUser user, string cmd, string value)
{
if (!Enabled)
{
return;
}
if (IsBettingClosed)
{
sender.SendMessage(Importance.Med, "Betting is not currently open.");
return;
}
Args args = value.ParseArguments(sender);
string result = args.GetOneWord();
if (string.IsNullOrWhiteSpace(result))
{
sender.SendMessage(Importance.Med, "Usage: '!result [player]'.");
return;
}
else if (!m_betting.Contains(result))
{
sender.SendMessage(Importance.High, "'{0}' not a valid player, valid players: {1}", result, string.Join(", ", m_betting));
return;
}
var winners = from bet in m_bets
where bet.Value.Item1.Equals(result, StringComparison.CurrentCultureIgnoreCase)
select bet;
var losers = from bet in m_bets
where !bet.Value.Item1.Equals(result, StringComparison.CurrentCultureIgnoreCase)
select bet;
int totalWinners = 0, totalLosers = 0;
foreach (var winner in winners)
{
AddPoints(winner.Key, winner.Value.Item2);
totalWinners++;
}
foreach (var loser in losers)
{
AddPoints(loser.Key, -loser.Value.Item2);
totalLosers++;
}
Tuple <TwitchUser, int>[] t = (from bet in m_bets
select new Tuple <TwitchUser, int>(bet.Key, m_points[bet.Key])).ToArray();
lock (m_sync)
foreach (var usr in m_bets.Keys)
{
m_queue.Add(new Tuple <TwitchUser, int>(usr, m_points[usr]));
}
m_event.Set();
ClearBetting();
CancelCallback();
sender.SendMessage(Importance.High, "Betting complete. {0} winners and {1} losers. Point totals can be found here: http://www.darkautumn.net/winter/chat.php?POINTS", totalWinners, totalLosers);
}
void m_bot_EndShutdown(WinterBot sender)
{
m_thread.Join();
}
void bot_MessageReceived(WinterBot sender, TwitchUser user, string text)
{
lock (m_sync)
m_messages.Add(new ChatMessage(DateTime.Now, user, Action.Chat, text));
}
void m_bot_BeginShutdown(WinterBot sender)
{
m_shutdown = true;
m_event.Set();
}
void bot_UserSubscribed(WinterBot sender, TwitchUser user)
{
lock (m_sync)
m_messages.Add(new ChatMessage(DateTime.Now, user, Action.Subbed));
}
void bot_ChatClear(WinterBot sender, TwitchUser user)
{
lock (m_sync)
m_messages.Add(new ChatMessage(DateTime.Now, user, Action.Clear));
}
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)));
}
void bot_ViewerCountChanged(WinterBot sender, int currentViewerCount)
{
lock (m_sync)
m_viewers.Add(new Tuple <DateTime, int>(DateTime.Now, currentViewerCount));
}
public JukeBox(WinterBot bot, WinterOptions options)
{
m_options = options;
bot.Tick += bot_Tick;
}
