public override void ExecuteCommand(EvtChatCommandArgs e)
{
string[] validInputs = InputGlobals.CurrentConsole.ValidInputs;
if (validInputs == null || validInputs.Length == 0)
{
BotProgram.MsgHandler.QueueMessage($"Interesting! There are no valid inputs for the {InputGlobals.CurrentConsoleVal} console!");
return;
}
StrBuilder.Clear();
StrBuilder.Append("Valid inputs for ").Append(InputGlobals.CurrentConsoleVal.ToString()).Append(": ");
for (int i = 0; i < validInputs.Length; i++)
{
StrBuilder.Append(validInputs[i]).Append(", ");
}
//Remove trailing comma
StrBuilder.Remove(StrBuilder.Length - 2, 2);
string validInputsStr = StrBuilder.ToString();
BotProgram.MsgHandler.QueueMessage(validInputsStr);
}
public override void ExecuteCommand(EvtChatCommandArgs e)
{
string displayLower = e.Command.ChatMessage.DisplayName.ToLower();
if (GroupBetCommand.UsersInBet.ContainsKey(displayLower) == false)
{
BotProgram.MsgHandler.QueueMessage("You're not in the group bet!");
return;
}
else
{
long betAmt = GroupBetCommand.UsersInBet[displayLower];
GroupBetCommand.UsersInBet.Remove(displayLower);
BotProgram.MsgHandler.QueueMessage($"{e.Command.ChatMessage.DisplayName} has backed out of the group bet and retained their {betAmt} credit(s)!");
//Check for ending the group bet if there are no longer enough participants
if (GroupBetCommand.BetStarted == true && GroupBetCommand.UsersInBet.Count < GroupBetCommand.MinUsersForBet)
{
GroupBetCommand.StopGroupBet();
int count = GroupBetCommand.UsersInBet.Count;
BotProgram.MsgHandler.QueueMessage($"Oh no! The group bet has ended since there are no longer enough participants. {GroupBetCommand.MinUsersForBet - count} more is/are required to start it up again!");
}
}
}
public override void ExecuteCommand(EvtChatCommandArgs e)
{
List <string> args = e.Command.ArgumentsAsList;
if (args.Count != 1)
{
BotProgram.MsgHandler.QueueMessage($"{Globals.CommandIdentifier}removemacro usage: \"#macroname\"");
return;
}
string macroName = args[0].ToLowerInvariant();
if (BotProgram.BotData.Macros.ContainsKey(macroName) == true)
{
char macroFirstChar = macroName[1];
//Remove from the parser macro list
List <string> parserMacroList = BotProgram.BotData.ParserMacroLookup[macroFirstChar];
parserMacroList.Remove(macroName);
if (parserMacroList.Count == 0)
{
BotProgram.BotData.ParserMacroLookup.Remove(macroFirstChar);
}
BotProgram.BotData.Macros.TryRemove(macroName, out string removedMacro);
BotProgram.SaveBotData();
BotProgram.MsgHandler.QueueMessage($"Removed macro {macroName}.");
}
else
{
BotProgram.MsgHandler.QueueMessage($"Macro \"{macroName}\" could not be found.");
}
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
string logMessage = args.Command.ArgumentsAsString;
if (string.IsNullOrEmpty(logMessage) == true)
{
QueueMessage(UsageMessage);
return;
}
string username = args.Command.ChatMessage.Username.ToLowerInvariant();
//Add a new log
GameLog newLog = new GameLog();
newLog.LogMessage = logMessage;
newLog.User = username;
newLog.LogDateTime = DateTime.UtcNow;
//Add the game log to the database
using (BotDBContext context = DatabaseManager.OpenContext())
{
context.GameLogs.Add(newLog);
context.SaveChanges();
}
QueueMessage("Successfully logged message!");
}
public override void ExecuteCommand(EvtChatCommandArgs e)
{
string name = e.Command.ChatMessage.DisplayName;
string nameToLower = name.ToLower();
if (DuelCommand.DuelRequests.ContainsKey(nameToLower) == true)
{
DuelCommand.DuelData data = DuelCommand.DuelRequests[nameToLower];
DuelCommand.DuelRequests.Remove(nameToLower);
TimeSpan diff = DateTime.Now - data.CurDuelTime;
if (diff.TotalMinutes >= DuelCommand.DUEL_MINUTES)
{
BotProgram.MsgHandler.QueueMessage("You are not in a duel or your duel has expired!");
return;
}
BotProgram.MsgHandler.QueueMessage($"{name} has denied to duel with {data.UserDueling} and miss out on a potential {data.BetAmount} credit(s)!");
}
else
{
BotProgram.MsgHandler.QueueMessage("You are not in a duel or your duel has expired!");
}
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
//Ignore with too few arguments
if (arguments.Count > 1)
{
QueueMessage(UsageMessage);
return;
}
if (arguments.Count == 0)
{
long maxRecentInputCount = DataHelper.GetSettingInt(SettingsConstants.MAX_USER_RECENT_INPUTS, 0L);
QueueMessage($"The max number of recent inputs stored per user is {maxRecentInputCount}. To change this number, pass an integer as an argument.");
return;
}
//Check for sufficient permissions
using (BotDBContext context = DatabaseManager.OpenContext())
{
User user = DataHelper.GetUserNoOpen(args.Command.ChatMessage.Username, context);
if (user == null || user.HasEnabledAbility(PermissionConstants.SET_MAX_USER_RECENT_INPUTS_ABILITY) == false)
{
QueueMessage("You do not have the ability to set the number of recent inputs stored per user!");
return;
}
}
string recentInputCountStr = arguments[0].ToLowerInvariant();
if (int.TryParse(recentInputCountStr, out int newRecentInputCount) == false)
{
QueueMessage("That's not a valid number!");
return;
}
if (newRecentInputCount < MIN_VALUE)
{
QueueMessage($"Value cannot be lower than {MIN_VALUE}!");
return;
}
using (BotDBContext context = DatabaseManager.OpenContext())
{
Settings userMaxRecentInputs = DataHelper.GetSettingNoOpen(SettingsConstants.MAX_USER_RECENT_INPUTS, context);
if (userMaxRecentInputs == null)
{
userMaxRecentInputs = new Settings(SettingsConstants.MAX_USER_RECENT_INPUTS, string.Empty, 0L);
context.SettingCollection.Add(userMaxRecentInputs);
}
userMaxRecentInputs.ValueInt = newRecentInputCount;
context.SaveChanges();
}
QueueMessage($"Set the max number of recent inputs stored per user to {newRecentInputCount}!");
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
if (string.IsNullOrEmpty(ValueStr) == true)
{
QueueMessage("Invalid file defined.");
return;
}
//First try to read the file as an absolute path
string codeText = FileHelpers.ReadFromTextFile(ValueStr);
//If that wasn't found, try a relative path
if (string.IsNullOrEmpty(codeText) == true)
{
codeText = FileHelpers.ReadFromTextFile(DataConstants.DataFolderPath, ValueStr);
}
if (string.IsNullOrEmpty(codeText) == true)
{
QueueMessage("Invalid source file. Double check its location.");
return;
}
//Execute the code
ExecuteCSharpScript(codeText);
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
if (arguments.Count == 0)
{
QueueMessage(UsageMessage);
return;
}
char[] msgArr = args.Command.ArgumentsAsString.ToCharArray();
Array.Reverse(msgArr);
string msg = new string(msgArr);
ClientServiceTypes clientServiceType = DataHelper.GetClientServiceType();
//Ignore any output starting with a "/" to avoid exploiting Twitch chat commands
if (clientServiceType == ClientServiceTypes.Twitch && msg.StartsWith('/') == true)
{
QueueMessage("!uoy rof sdnammoc tahc hctiwT oN");
return;
}
QueueMessage(msg);
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
StringBuilder strBuilder = null;
using (BotDBContext context = DatabaseManager.OpenContext())
{
//No abilities
if (context.PermAbilities.Count() == 0)
{
QueueMessage("There are no permission abilities!");
return;
}
//Order alphabetically
IOrderedQueryable<PermissionAbility> permAbilities = context.PermAbilities.OrderBy(p => p.Name);
strBuilder = new StringBuilder(250);
strBuilder.Append("Hi, ").Append(args.Command.ChatMessage.Username);
strBuilder.Append(", here's a list of all permission abilities: ");
foreach (PermissionAbility pAbility in permAbilities)
{
strBuilder.Append(pAbility.Name);
strBuilder.Append(',').Append(' ');
}
}
strBuilder.Remove(strBuilder.Length - 2, 2);
int maxCharCount = (int)DataHelper.GetSettingInt(SettingsConstants.BOT_MSG_CHAR_LIMIT, 500L);
QueueMessageSplit(strBuilder.ToString(), maxCharCount, ", ");
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
long curResMode = DataHelper.GetSettingInt(SettingsConstants.DEMOCRACY_RESOLUTION_MODE, 0L);
DemocracyResolutionModes resMode = (DemocracyResolutionModes)curResMode;
//See the virtual controller
if (arguments.Count == 0)
{
QueueMessage($"The current Democracy resolution mode is {resMode}. To set the resolution mode, add one as an argument: {CachedResolutionModesStr}");
return;
}
//Invalid number of arguments
if (arguments.Count > 1)
{
QueueMessage(UsageMessage);
return;
}
using (BotDBContext context = DatabaseManager.OpenContext())
{
//Check if the user has the ability to set the mode
User user = DataHelper.GetUserNoOpen(args.Command.ChatMessage.Username, context);
if (user != null && user.HasEnabledAbility(PermissionConstants.SET_DEMOCRACY_RESOLUTION_MODE_ABILITY) == false)
{
QueueMessage("You don't have the ability to set the Democracy resolution mode!");
return;
}
}
string resModeStr = arguments[0];
//Parse
if (EnumUtility.TryParseEnumValue(resModeStr, out DemocracyResolutionModes parsedResMode) == false)
{
QueueMessage($"Please enter a resolution mode: {CachedResolutionModesStr}");
return;
}
//Same mode
if (parsedResMode == resMode)
{
QueueMessage($"The current resolution mode is already {resMode}!");
return;
}
using (BotDBContext context = DatabaseManager.OpenContext())
{
//Set the value and save
Settings resModeSetting = DataHelper.GetSettingNoOpen(SettingsConstants.DEMOCRACY_RESOLUTION_MODE, context);
resModeSetting.ValueInt = (long)parsedResMode;
context.SaveChanges();
}
QueueMessage($"Changed the Democracy resolution mode from {resMode} to {parsedResMode}!");
}
public void HandleCommand(EvtChatCommandArgs e)
{
if (e == null || e.Command == null || e.Command.ChatMessage == null)
{
Console.WriteLine($"{nameof(EvtChatCommandArgs)} or its Command or ChatMessage is null! Not parsing command");
return;
}
string userToLower = e.Command.ChatMessage.DisplayName.ToLower();
//Don't handle certain users (Ex. MrMacroBot)
if (ExemptUsers.Contains(userToLower) == true)
{
Console.WriteLine($"User {e.Command.ChatMessage.DisplayName} is exempt and I won't take commands from them");
return;
}
User user = BotProgram.GetOrAddUser(userToLower);
string commandToLower = e.Command.CommandText.ToLower();
if (CommandDict.TryGetValue(commandToLower, out BaseCommand command) == true)
{
//Handle permissions
if (user.Level >= command.AccessLevel)
{
command.ExecuteCommand(e);
}
else
{
BotProgram.MsgHandler.QueueMessage(INVALID_ACCESS_MESSAGE);
}
}
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
if (arguments.Count < 2)
{
QueueMessage(UsageMessage);
return;
}
string memeName = arguments[0];
string memeValue = arguments[1];
if (memeName.ElementAt(0) == '/' || memeValue.ElementAt(0) == '/')
{
QueueMessage("Memes cannot start with Twitch chat commands!");
return;
}
if (memeName.StartsWith(Parser.DEFAULT_PARSER_REGEX_MACRO_INPUT) == true)
{
QueueMessage($"Memes cannot start with \"{Parser.DEFAULT_PARSER_REGEX_MACRO_INPUT}\".");
return;
}
if (memeName.ElementAt(0) == DataConstants.COMMAND_IDENTIFIER)
{
QueueMessage($"Memes cannot start with \'{DataConstants.COMMAND_IDENTIFIER}\'.");
return;
}
if (memeName.Length > MAX_MEME_NAME_LENGTH)
{
QueueMessage($"Memes may have up to a max of {MAX_MEME_NAME_LENGTH} characters in their name!");
return;
}
string memeToLower = memeName.ToLowerInvariant();
using (BotDBContext context = DatabaseManager.OpenContext())
{
Meme meme = context.Memes.FirstOrDefault(m => m.MemeName == memeToLower);
string actualMemeValue = args.Command.ArgumentsAsString.Remove(0, memeName.Length + 1);
if (meme != null)
{
meme.MemeValue = actualMemeValue;
QueueMessage("Meme overwritten!");
}
else
{
Meme newMeme = new Meme(memeToLower, actualMemeValue);
context.Memes.Add(newMeme);
}
context.SaveChanges();
}
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
string username = args.Command.ChatMessage.Username.ToLowerInvariant();
GroupBetRoutine groupBetRoutine = RoutineHandler.FindRoutine <GroupBetRoutine>();
if (groupBetRoutine == null ||
groupBetRoutine.TryGetParticipant(username, out GroupBetRoutine.ParticipantData participantData) == false)
{
QueueMessage("You're not in the group bet!");
return;
}
groupBetRoutine.RemoveParticipant(username);
string creditsName = DataHelper.GetCreditsName();
QueueMessage($"{username} has backed out of the group bet and retained their {participantData.ParticipantBet} {creditsName.Pluralize(false, participantData.ParticipantBet)}!");
int participantCount = groupBetRoutine.ParticipantCount;
int minParticipants = groupBetRoutine.MinParticipants;
//Check for ending the group bet if there are no longer enough participants
if (participantCount < minParticipants)
{
//If no one is in the group bet, end it entirely
if (participantCount == 0)
{
RoutineHandler.RemoveRoutine(groupBetRoutine);
}
QueueMessage($"Oh no! The group bet has ended since there are no longer enough participants. {minParticipants - participantCount} more is/are required to start it up again!");
}
}
public override void ExecuteCommand(EvtChatCommandArgs e)
{
string msg = e.Command.ArgumentsAsString;
if (msg == null)
{
msg = string.Empty;
}
BotProgram.BotData.GameMessage = msg;
//Always save the message to a file so it updates on OBS
/*For reading from this file on OBS:
* 1. Create Text (GDI+)
* 2. Check the box labeled "Read from file"
* 3. Browse and select the file
*/
if (Globals.SaveToTextFile(Globals.GameMessageFilename, BotProgram.BotData.GameMessage) == false)
{
BotProgram.MsgHandler.QueueMessage($"Unable to save message to file");
}
BotProgram.SaveBotData();
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
string creditsName = DataHelper.GetCreditsName();
long median = 0;
using (BotDBContext context = DatabaseManager.OpenContext())
{
if (context.Users.Count() == 0)
{
QueueMessage("There are no users in the database!");
return;
}
List <User> orderedCredits = context.Users.OrderByDescending(u => u.Stats.Credits).ToList();
int medianIndex = orderedCredits.Count / 2;
if (medianIndex >= orderedCredits.Count)
{
QueueMessage("Sorry, there's not enough data available in the database!");
return;
}
median = orderedCredits[medianIndex].Stats.Credits;
}
QueueMessage($"The median number of {creditsName.Pluralize(false, 0)} in the database is {median}!");
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
if (arguments.Count > 1)
{
QueueMessage(UsageMessage);
return;
}
string infoUsername = (arguments.Count == 1) ? arguments[0].ToLowerInvariant() : args.Command.ChatMessage.Username.ToLowerInvariant();
using (BotDBContext context = DatabaseManager.OpenContext())
{
User infoUser = DataHelper.GetUserNoOpen(infoUsername, context);
if (infoUser == null)
{
QueueMessage($"User does not exist in database!");
return;
}
if (infoUser.IsOptedOut == true)
{
QueueMessage($"User: {infoUser.Name} | Level: {infoUser.Level} ({(PermissionLevels)infoUser.Level}) | Controller Port: {infoUser.ControllerPort}");
return;
}
//Print the user's information
QueueMessage($"User: {infoUser.Name} | Level: {infoUser.Level} ({(PermissionLevels)infoUser.Level}) | Controller Port: {infoUser.ControllerPort} | Total Inputs: {infoUser.Stats.ValidInputCount} | Total Messages: {infoUser.Stats.TotalMessageCount}");
}
}
public override void ExecuteCommand(EvtChatCommandArgs e)
{
List <string> args = e.Command.ArgumentsAsList;
if (args == null || args.Count <= 0)
{
BotProgram.MsgHandler.QueueMessage("Choose one or more people to high five!");
return;
}
string highFive = string.Empty;
for (int i = 0; i < args.Count; i++)
{
int nextInd = i + 1;
if (i > 0)
{
highFive += ", ";
if (nextInd == args.Count)
{
highFive += "and ";
}
}
highFive += args[i];
}
BotProgram.MsgHandler.QueueMessage($"{e.Command.ChatMessage.DisplayName} high fives {highFive}!");
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
QueueMessage("Checking to initialize default values for missing database entries.");
int entriesAdded = 0;
using (BotDBContext context = DatabaseManager.OpenContext())
{
//Tell it to force initialize defaults
Settings forceInitSetting = DataHelper.GetSettingNoOpen(SettingsConstants.FORCE_INIT_DEFAULTS, context);
if (forceInitSetting != null)
{
forceInitSetting.ValueInt = 1;
context.SaveChanges();
}
}
entriesAdded = DataHelper.InitDefaultData();
if (entriesAdded > 0)
{
QueueMessage($"Added {entriesAdded} additional entries to the database. Make sure to reload data if you're expecting new commands.");
}
else
{
QueueMessage("No new entries added.");
}
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
StringBuilder strBuilder = null;
using (BotDBContext context = DatabaseManager.OpenContext())
{
int memeCount = context.Memes.Count();
if (memeCount == 0)
{
QueueMessage("There are no memes!");
return;
}
//The capacity is the estimated average number of characters for each meme multiplied by the number of memes
strBuilder = new StringBuilder(memeCount * 20);
foreach (Meme meme in context.Memes)
{
strBuilder.Append(meme.MemeName).Append(',').Append(' ');
}
}
strBuilder.Remove(strBuilder.Length - 2, 2);
int maxCharCount = (int)DataHelper.GetSettingInt(SettingsConstants.BOT_MSG_CHAR_LIMIT, 500L);
QueueMessageSplit(strBuilder.ToString(), maxCharCount, ", ");
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
if (arguments.Count != 1)
{
QueueMessage(UsageMessage);
return;
}
string macroName = arguments[0].ToLowerInvariant();
using (BotDBContext context = DatabaseManager.OpenContext())
{
InputMacro macro = context.Macros.FirstOrDefault(m => m.MacroName == macroName);
if (macro == null)
{
QueueMessage($"Input macro \"{macroName}\" could not be found.");
return;
}
context.Macros.Remove(macro);
context.SaveChanges();
}
QueueMessage($"Removed input macro \"{macroName}\".");
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
//Soft reload with no arguments
if (arguments.Count == 0)
{
SoftReload();
return;
}
if (arguments.Count > 1)
{
QueueMessage(UsageMessage);
return;
}
string arg1 = arguments[0].ToLowerInvariant();
//Soft reloads
if (arg1 == SOFT_RELOAD_ARG)
{
SoftReload();
}
else if (arg1 == HARD_RELOAD_ARG)
{
HardReload();
}
else
{
QueueMessage(UsageMessage);
}
}
public override void ExecuteCommand(EvtChatCommandArgs e)
{
string args = e.Command.ArgumentsAsString.ToLower();
if (BotProgram.BotData.Achievements.AchievementDict.TryGetValue(args, out Achievement achievement) == false)
{
BotProgram.MsgHandler.QueueMessage("There are no achievements with that name!");
return;
}
//string name = e.Command.ChatMessage.DisplayName;
//string nameToLower = name.ToLower();
//User user = BotProgram.GetUser(nameToLower);
//if (user == null)
//{
// return;
//}
string achStr = achievement.Description.ToString();
if (achievement.CreditReward > 0)
{
achStr += " | " + achievement.CreditReward.ToString() + " credit reward.";
}
BotProgram.MsgHandler.QueueMessage(achStr);
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
if (arguments.Count != 1)
{
QueueMessage(UsageMessage);
return;
}
string consoleName = arguments[0].ToLowerInvariant();
int consoleID = 1;
string actualConsoleName = string.Empty;
using (BotDBContext context = DatabaseManager.OpenContext())
{
GameConsole console = context.Consoles.FirstOrDefault(c => c.Name == consoleName);
//Check if a valid console is specified
if (console == null)
{
QueueMessage($"\"{consoleName}\" is not a valid console.");
return;
}
consoleID = console.ID;
}
StringBuilder stringBuilder = null;
using (BotDBContext context = DatabaseManager.OpenContext())
{
IQueryable <InputSynonym> synonyms = context.InputSynonyms.Where(syn => syn.ConsoleID == consoleID);
int count = synonyms.Count();
if (count == 0)
{
QueueMessage($"The {consoleName} console does not have any input synonyms.");
return;
}
stringBuilder = new StringBuilder(count * 15);
stringBuilder.Append("Synonyms for ").Append(consoleName).Append(':').Append(' ');
//Show all input synonyms for this console
foreach (InputSynonym synonym in synonyms)
{
stringBuilder.Append('{').Append(' ').Append(synonym.SynonymName).Append(',').Append(' ');
stringBuilder.Append(synonym.SynonymValue).Append(' ').Append('}').Append(',').Append(' ');
}
}
stringBuilder.Remove(stringBuilder.Length - 2, 2);
int maxCharCount = (int)DataHelper.GetSettingInt(SettingsConstants.BOT_MSG_CHAR_LIMIT, 500L);
QueueMessageSplit(stringBuilder.ToString(), maxCharCount, ", ");
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
if (arguments.Count != 1)
{
QueueMessage(UsageMessage);
return;
}
string macroName = arguments[0].ToLowerInvariant();
string message = string.Empty;
using (BotDBContext context = DatabaseManager.OpenContext())
{
InputMacro macro = context.Macros.FirstOrDefault(m => m.MacroName == macroName);
if (macro == null)
{
message = $"Input macro \"{macroName}\" not found. For dynamic input macros, use the generic form (Ex. \"#test(*)\").";
}
else
{
message = $"{macro.MacroName} = {macro.MacroValue}";
}
}
QueueMessage(message);
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
if (arguments.Count > 1)
{
QueueMessage(UsageMessage);
return;
}
string creditsUsername = (arguments.Count == 1) ? arguments[0].ToLowerInvariant() : args.Command.ChatMessage.Username.ToLowerInvariant();
long creditsCount = 0L;
using (BotDBContext context = DatabaseManager.OpenContext())
{
User creditsUser = DataHelper.GetUserNoOpen(creditsUsername, context);
if (creditsUser == null)
{
QueueMessage($"User does not exist in database!");
return;
}
creditsCount = creditsUser.Stats.Credits;
}
string creditsName = DataHelper.GetCreditsName();
QueueMessage($"{creditsUsername} has {creditsCount} {creditsName.Pluralize(false, creditsCount)}!");
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
List <string> arguments = args.Command.ArgumentsAsList;
if (arguments.Count != 2)
{
QueueMessage(UsageMessage);
return;
}
//Parse the numbers
if (int.TryParse(arguments[0], out int num1) == true && int.TryParse(arguments[1], out int num2) == true)
{
//Get the true min and max values
int min = Math.Min(num1, num2);
int max = Math.Max(num1, num2);
int randNum = Rand.Next(min, max);
QueueMessage($"The random number between {min} and {max} is: {randNum}! Play again!");
}
else
{
QueueMessage(UsageMessage);
}
}
public override void ExecuteCommand(EvtChatCommandArgs e)
{
string name = e.Command.ChatMessage.DisplayName;
string nameToLower = name.ToLower();
User user = BotProgram.GetOrAddUser(nameToLower);
if (user == null)
{
return;
}
if (user.OptedOut == false)
{
user.SetOptOut(true);
BotProgram.SaveBotData();
BotProgram.MsgHandler.QueueMessage("Opted out of bot stats!");
return;
}
else if (user.OptedOut == true)
{
user.SetOptOut(false);
BotProgram.SaveBotData();
BotProgram.MsgHandler.QueueMessage("Opted back into bot stats!");
return;
}
}
public override void ExecuteCommand(EvtChatCommandArgs e)
{
//Reload settings and bot data
BotProgram.LoadSettingsAndBotData();
BotProgram.MsgHandler.QueueMessage("Reloaded bot settings and data!");
}
public override void ExecuteCommand(EvtChatCommandArgs args)
{
string versionString = DataHelper.GetSettingString(SettingsConstants.DATA_VERSION_NUM, "Unknown??");
ValueStr = $"This bot is running TRBot version {Application.VERSION_NUMBER} with data version {versionString}!";
base.ExecuteCommand(args);
}
public override void ExecuteCommand(EvtChatCommandArgs e)
{
List <string> args = e.Command.ArgumentsAsList;
if (args.Count < 2)
{
BotProgram.MsgHandler.QueueMessage($"{Globals.CommandIdentifier}addmeme usage: memename memevalue");
return;
}
if (args[0].ElementAt(0) == '/' || args[1].ElementAt(0) == '/')
{
BotProgram.MsgHandler.QueueMessage("Memes cannot start with Twitch chat commands!");
return;
}
if (args[0].ElementAt(0) == Globals.CommandIdentifier)
{
BotProgram.MsgHandler.QueueMessage($"Memes cannot start with \'{Globals.CommandIdentifier}\'");
return;
}
if (args[0].ElementAt(0) == Globals.MacroIdentifier)
{
BotProgram.MsgHandler.QueueMessage($"Memes cannot start with \'{Globals.MacroIdentifier}\'");
return;
}
if (args[0].Length > MAX_MEME_LENGTH)
{
BotProgram.MsgHandler.QueueMessage($"The max meme length is {MAX_MEME_LENGTH} characters!");
return;
}
string memeToLower = args[0].ToLower();
bool sendOverwritten = false;
if (BotProgram.BotData.Memes.ContainsKey(memeToLower) == true)
{
BotProgram.BotData.Memes.TryRemove(memeToLower, out string meme);
sendOverwritten = true;
}
string actualMeme = e.Command.ArgumentsAsString.Remove(0, args[0].Length + 1);
BotProgram.BotData.Memes.TryAdd(memeToLower, actualMeme);
BotProgram.SaveBotData();
if (sendOverwritten == true)
{
BotProgram.MsgHandler.QueueMessage("Meme overwritten!");
}
else
{
MemesCommand.CacheMemesString();
}
}
