/// <summary> /// Throws an item at a viewer and rates its effectiveness against the victim /// </summary> /// <param name="chatter">User that sent the message</param> private async Task <DateTime> ThrowAsync(TwitchChatter chatter) { try { int indexAction = chatter.Message.IndexOf(" "); if (chatter.Message.StartsWith("!throw @")) { _irc.SendPublicChatMessage($"Please throw an item to a user @{chatter.DisplayName}"); } else { string recipient = chatter.Message.Substring(chatter.Message.IndexOf("@") + 1); string item = chatter.Message.Substring(indexAction, chatter.Message.IndexOf("@") - indexAction - 1); ReactionCommand(_irc, chatter.DisplayName, recipient, $"Stop throwing {item} at yourself", $"throws {item} at", $". {Effectiveness()}"); return(DateTime.Now.AddSeconds(20)); } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "Gen", "Throw(TwitchChatter)", false, "!throw", chatter.Message); } return(DateTime.Now); }
public override async Task <(bool, DateTime)> ExecCommandAsync(TwitchChatter chatter, string requestedCommand) { try { switch (requestedCommand) { case "!refreshreminders": return(true, await RefreshRemindersAsync()); case "!refreshbossfight": return(true, await RefreshBossFightAsync()); case "!refreshcommands": return(true, await RefreshCommandsAsync()); default: break; } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "ReminderFeature", "ExecCommand(TwitchChatter, string)", false, requestedCommand, chatter.Message); } return(false, DateTime.Now); }
/// <summary> /// Put a cooldown for a user on a command /// </summary> /// <param name="chatter"></param> /// <param name="cooldown"></param> public void AddCooldown(TwitchChatter chatter, DateTime cooldown, string command) { if (cooldown > DateTime.Now) { _cooldownUsers.Add(new CooldownUser { Username = chatter.Username, Cooldown = cooldown, Command = command, Warned = false }); } if (command == "!wrongsong") { // Allow the user to request another song in case if cooldown exists CooldownUser songRequestCooldown = _cooldownUsers.FirstOrDefault(u => u.Username == chatter.Username && u.Command == "!ytsr"); if (songRequestCooldown != null) { _cooldownUsers.Remove(songRequestCooldown); } } }
public override async Task <(bool, DateTime)> ExecCommandAsync(TwitchChatter chatter, string requestedCommand) { try { switch (requestedCommand) { case "!partyup": return(true, await PartyUpAsync(chatter)); case "!partyuprequestlist": return(true, await PartyUpRequestListAsync()); case "!partyuplist": return(true, await PartyUpListAsync()); case "!poppartyup": case "!poppartyuprequest": return(true, await PopPartyUpRequestAsync()); default: break; } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "PartyUpFeature", "ExecCommand(TwitchChatter, string)", false, requestedCommand, chatter.Message); } return(false, DateTime.Now); }
public override async Task <(bool, DateTime)> ExecCommandAsync(TwitchChatter chatter, string requestedCommand) { try { switch (requestedCommand) { case "!roulette": return(true, await RussianRoulette(chatter)); case "!bankheist": case "!heist": return(true, await BankHeist(chatter)); case "!raid": case "!bossfight": return(true, await BossFight(chatter)); default: break; } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "MinigameFeature", "ExecCommand(TwitchChatter, string)", false, requestedCommand, chatter.Message); } return(false, DateTime.Now); }
public override async Task <(bool, DateTime)> ExecCommandAsync(TwitchChatter chatter, string requestedCommand) { try { switch (requestedCommand) { case "!srstart": return(true, await StartAsync()); case "!srstop": return(true, await StopAsync()); case "!srpause": return(true, await PauseAsync()); case "!sraod": return(true, await SetAudioOutputDeviceAsync(chatter)); case "!srshuffle": return(true, await PersonalPlaylistShuffleAsync(chatter)); case "!srplay": return(true, await PlayAsync()); case "!srvolume": if ((chatter.Message.StartsWith("!srvolume ")) && HasPermission("!srvolume", DetermineChatterPermissions(chatter), _rolePermissions, true)) { return(true, await SetVolumeAsync(chatter)); } else if (chatter.Message == "!srvolume") { return(true, await ShowVolumeAsync(chatter)); } break; case "!srskip": return(true, await Skip(chatter)); case "!srtime": if ((chatter.Message.StartsWith("!srtime ")) && HasPermission("!srtime", DetermineChatterPermissions(chatter), _rolePermissions, true)) { return(true, await SetTimeAsync(chatter)); } else if (chatter.Message == "!srtime") { return(true, await ShowTimeAsync(chatter)); } break; default: break; } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "LibVLCSharpPlayerFeature", "ExecCommand(TwitchChatter, string)", false, requestedCommand, chatter.Message); } return(false, DateTime.Now); }
private async Task <DateTime> SetGenericIgnAsync(TwitchChatter chatter) { try { string message = chatter.Message; string gameIgn = message.Substring(message.IndexOf(" ") + 1); // Get current game name ChannelJSON json = await _twitchInfo.GetBroadcasterChannelByIdAsync(); string gameTitle = json.Game; InGameUsername ign = await _ign.GetInGameUsernameAsync(_broadcasterInstance.DatabaseId); if (ign == null) { await _ign.CreateInGameUsernameAsync(null, _broadcasterInstance.DatabaseId, gameIgn); _irc.SendPublicChatMessage($"Yay! You've set your generic IGN to \"{gameIgn}\" @{chatter.DisplayName}"); } else { ign.Message = gameIgn; await _ign.UpdateInGameUsernameAsync(ign.Id, _broadcasterInstance.DatabaseId, ign); _irc.SendPublicChatMessage($"Yay! You've updated your generic IGN to \"{gameIgn}\" @{chatter.DisplayName}"); } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "InGameNameFeature", "SetGenericIgn(TwitchChatter)", false, "!setgenericign", chatter.Message); } return(DateTime.Now); }
/// <summary> /// Displays the current song being played from Spotify /// </summary> /// <param name="chatter">User that sent the message</param> public static async Task <string> SpotifyCurrentSongAsync(TwitchChatter chatter, SpotifyWebClient spotify) { PlaybackContext playbackContext = await spotify.GetPlaybackAsync(); if (playbackContext != null && playbackContext.IsPlaying) { string artistName = ""; foreach (SimpleArtist simpleArtist in playbackContext.Item.Artists) { artistName += $"{simpleArtist.Name}, "; } artistName = artistName.ReplaceLastOccurrence(", ", ""); TimeSpan progressTimeSpan = TimeSpan.FromMilliseconds(playbackContext.ProgressMs); TimeSpan durationTimeSpan = TimeSpan.FromMilliseconds(playbackContext.Item.DurationMs); return($"@{chatter.DisplayName} <-- Now playing from Spotify: \"{playbackContext.Item.Name}\" by {artistName} " + "https://open.spotify.com/track/" + playbackContext.Item.Id + " " + $"Currently playing at {progressTimeSpan.ReformatTimeSpan()} of {durationTimeSpan.ReformatTimeSpan()}"); } else { return($"Nothing is playing at the moment @{chatter.DisplayName}"); } }
public override async Task <(bool, DateTime)> ExecCommandAsync(TwitchChatter chatter, string requestedCommand) { try { switch (requestedCommand) { case "!autotweet": return(true, await SetAutoTweetAsync(chatter)); case "!tweet": return(true, await TweetAsync(chatter)); case "!live": return(true, await LiveAsync()); case "!twitter": return(true, await TwitterLinkAsync()); default: break; } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "TwitterFeature", "ExecCommand(TwitchChatter, string)", false, requestedCommand, chatter.Message); } return(false, DateTime.Now); }
public async Task CmdLibVLCSharpPlayerVolume(TwitchChatter chatter) { try { bool validMessage = int.TryParse(chatter.Message.Substring(chatter.Message.IndexOf(" ") + 1), out int volumePercentage); if (validMessage) { if (await _libVLCSharpPlayer.SetVolume(volumePercentage)) { _irc.SendPublicChatMessage($"Song request volume set to {volumePercentage}% @{chatter.DisplayName}"); } else if (volumePercentage < 1 || volumePercentage > 100) { _irc.SendPublicChatMessage($"Please use a value for the song request volume from 1-100 @{chatter.DisplayName}"); } } else { _irc.SendPublicChatMessage($"Requested volume not valid. Please set the song request volume from 1-100 @{chatter.DisplayName}"); } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "CmdMod", "CmdLibVLCSharpPlayerVolume(TwitchChatter)", false, "!srvolume", chatter.Message); } }
public async Task CmdLibVLCSharpPlayerSkip(TwitchChatter chatter) { try { bool validMessage = int.TryParse(chatter.Message.Substring(chatter.Message.IndexOf(" ") + 1), out int songSkipCount); if (!validMessage) { await _libVLCSharpPlayer.Skip(); } else { await _libVLCSharpPlayer.Skip(songSkipCount); } string songRequest = _youTubeClientInstance.ShowPlayingSongRequest(_libVLCSharpPlayer.CurrentSongRequestPlaylistItem); if (!string.IsNullOrEmpty(songRequest)) { _irc.SendPublicChatMessage($"@{chatter.DisplayName} <-- Now playing: {songRequest}"); } else { _irc.SendPublicChatMessage($"Unable to display the current song @{chatter.DisplayName}"); } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "CmdMod", "CmdLibVLCSharpPlayerSkip(TwitchChatter)", false, "!srskip"); } }
public override async Task <(bool, DateTime)> ExecCommandAsync(TwitchChatter chatter, string requestedCommand) { try { switch (requestedCommand) { case "!msl": case "!addmsl": if ((chatter.Message.StartsWith("!msl ") || chatter.Message.StartsWith("!addmsl ")) && HasPermission("!addmsl", DetermineChatterPermissions(chatter), _rolePermissions)) { return(true, await AddUsersAsync(chatter)); } else if (chatter.Message == "!msl") { return(true, await ShowLinkAsync(chatter)); } break; case "!resetmsl": return(true, await ResetLinkAsync(chatter)); default: break; } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "MultiLinkUserFeature", "ExecCommand(TwitchChatter, string)", false, requestedCommand, chatter.Message); } return(false, DateTime.Now); }
/// <summary> /// Reset the MultiStream link to allow the link to be reconfigured /// </summary> /// <param name="chatter"></param> /// <param name="multiStreamUsers">List of users that have already been added to the link</param> public async Task <List <string> > CmdResetMultiStreamLink(TwitchChatter chatter, List <string> multiStreamUsers) { try { multiStreamUsers = new List <string>(); string resultMsg = "MultiStream link has been reset. " + $"Please reconfigure the link if you are planning on using it in the near future @{chatter.Username}"; if (chatter.Username == _botConfig.Broadcaster.ToLower()) { _irc.SendPublicChatMessage(resultMsg); } else { _irc.SendPublicChatMessage($"{resultMsg} @{_botConfig.Broadcaster.ToLower()}"); } return(multiStreamUsers); } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "CmdMod", "CmdResetMultiStream(string, ref List<string>)", false, "!resetmsl"); } return(new List <string>()); }
public override async Task <(bool, DateTime)> ExecCommandAsync(TwitchChatter chatter, string requestedCommand) { try { switch (requestedCommand) { case "!resetjoin": return(true, await ResetJoinAsync(chatter)); case "!listjoin": return(true, await ListJoinAsync(chatter)); case "!invite": return(true, await InviteAsync(chatter)); case "!popjoin": return(true, await PopJoinAsync(chatter)); default: break; } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "JoinStreamerFeature", "ExecCommand(TwitchChatter, string)", false, requestedCommand, chatter.Message); } return(true, DateTime.Now); }
/// <summary> /// Set delay for messages based on the latency of the stream /// </summary> /// <param name="chatter"></param> private async Task <DateTime> SetLatencyAsync(TwitchChatter chatter) { try { int latency = -1; bool isValidInput = int.TryParse(ParseChatterCommandParameter(chatter), out latency); if (!isValidInput || latency < 0) { _irc.SendPublicChatMessage("Please insert a valid positive alloted amount of time (in seconds)"); } else { _botConfig.StreamLatency = latency; SaveAppConfigSettings(latency.ToString(), "streamLatency", _appConfig); _irc.SendPublicChatMessage($"Bot settings for stream latency set to {_botConfig.StreamLatency} second(s) @{chatter.DisplayName}"); } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "GeneralFeature", "SetLatency(TwitchChatter)", false, "!setlatency"); } return(DateTime.Now); }
public override async Task <(bool, DateTime)> ExecCommandAsync(TwitchChatter chatter, string requestedCommand) { try { switch (requestedCommand) { case "!followsince": return(true, await FollowSinceAsync(chatter)); case "!rank": return(true, await ViewRankAsync(chatter)); case "!setregularhours": return(true, await SetRegularFollowerHoursAsync(chatter)); case "!ranktop3": return(true, await LeaderboardRankAsync(chatter)); default: break; } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "FollowerFeature", "ExecCommand(TwitchChatter, string)", false, requestedCommand, chatter.Message); } return(false, DateTime.Now); }
/// <summary> /// Enables tweets to be sent out from this bot (both auto publish tweets and manual tweets) /// </summary> private async Task <DateTime> SetAutoTweetAsync(TwitchChatter chatter) { try { if (!_twitterInstance.HasCredentials) { _irc.SendPublicChatMessage($"You are missing twitter info @{_botConfig.Broadcaster}"); } else { string message = ParseChatterCommandParameter(chatter); bool enableTweets = SetBooleanFromMessage(message); string boolValue = enableTweets ? "true" : "false"; _botConfig.EnableTweets = true; SaveAppConfigSettings(boolValue, "enableTweets", _appConfig); _irc.SendPublicChatMessage($"@{_botConfig.Broadcaster} : Automatic tweets is set to \"{_botConfig.EnableTweets}\""); } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "TwitterFeature", "EnableTweet()", false, "!sendtweet on"); } return(DateTime.Now); }
/// <summary> /// Set delay for messages based on the latency of the stream /// </summary> /// <param name="chatter"></param> public async void CmdSetLatency(TwitchChatter chatter) { try { int latency = -1; bool isValidInput = int.TryParse(chatter.Message.Substring(chatter.Message.IndexOf(" ")), out latency); if (!isValidInput || latency < 0) { _irc.SendPublicChatMessage("Please insert a valid positive alloted amount of time (in seconds)"); } else { _botConfig.StreamLatency = latency; _appConfig.AppSettings.Settings.Remove("streamLatency"); _appConfig.AppSettings.Settings.Add("streamLatency", latency.ToString()); _appConfig.Save(ConfigurationSaveMode.Modified); ConfigurationManager.RefreshSection("TwitchBotConfiguration"); _irc.SendPublicChatMessage($"Bot settings for stream latency set to {_botConfig.StreamLatency} second(s) @{chatter.DisplayName}"); } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "CmdMod", "CmdSetLatency(TwitchChatter)", false, "!setlatency"); } }
private async Task <DateTime> SetRegularFollowerHoursAsync(TwitchChatter chatter) { try { bool validInput = int.TryParse(ParseChatterCommandParameter(chatter), out int regularHours); if (!validInput) { _irc.SendPublicChatMessage($"I can't process the time you've entered. " + $"Please insert positive hours @{_botConfig.Broadcaster}"); return(DateTime.Now); } else if (regularHours < 1) { _irc.SendPublicChatMessage($"Please insert positive hours @{_botConfig.Broadcaster}"); return(DateTime.Now); } _botConfig.RegularFollowerHours = regularHours; _appConfig.AppSettings.Settings.Remove("regularFollowerHours"); _appConfig.AppSettings.Settings.Add("regularFollowerHours", regularHours.ToString()); _appConfig.Save(ConfigurationSaveMode.Modified); ConfigurationManager.RefreshSection("TwitchBotConfiguration"); Console.WriteLine($"Regular followers are set to {_botConfig.RegularFollowerHours}"); _irc.SendPublicChatMessage($"{_botConfig.Broadcaster} : Regular followers now need {_botConfig.RegularFollowerHours} hours"); } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "FollowerFeature", "SetRegularFollowerHours(TwitchChatter)", false, "!setregularhours"); } return(DateTime.Now); }
/// <summary> /// Checks if a user/command is on a cooldown from a particular command /// </summary> /// <param name="command"></param> /// <param name="chatter"></param> /// <returns></returns> public bool IsCommandOnCooldown(string command, TwitchChatter chatter, IrcClient irc, bool hasGlobalCooldown = false) { CooldownUser cooldown = null; if (!hasGlobalCooldown) { cooldown = _cooldownUsers.FirstOrDefault(u => u.Username == chatter.Username && u.Command == command); } else { cooldown = _cooldownUsers.FirstOrDefault(u => u.Command == command); } if (cooldown == null) { return(false); } else if (cooldown.Cooldown < DateTime.Now) { _cooldownUsers.Remove(cooldown); return(false); } if (!cooldown.Warned) { string specialCooldownMessage = ""; // ToDo: Find more graceful way to prevent spam of commands with a global cooldown if (!hasGlobalCooldown) { cooldown.Warned = true; // prevent spamming cooldown message per personal cooldown specialCooldownMessage = "a PERSONAL"; } else { specialCooldownMessage = "a GLOBAL"; } string timespanMessage = ""; TimeSpan timespan = cooldown.Cooldown - DateTime.Now; if (timespan.Minutes > 0) { timespanMessage = $"{timespan.Minutes} minute(s) and {timespan.Seconds} second(s)"; } else if (timespan.Seconds == 0) { timespanMessage = $"{timespan.Milliseconds} millisecond(s)"; } else { timespanMessage = $"{timespan.Seconds} second(s)"; } irc.SendPublicChatMessage($"The {command} command is currently on {specialCooldownMessage} cooldown @{chatter.DisplayName} for {timespanMessage}"); } return(true); }
/// <summary> /// Parse out the command from the chatter's message /// </summary> /// <param name="chatter"></param> /// <returns></returns> protected string ParseChatterCommandName(TwitchChatter chatter) { int spaceIndex = chatter.Message.IndexOf(" ") > 0 ? chatter.Message.IndexOf(" ") : chatter.Message.Length; return(chatter.Message.Substring(0, spaceIndex).ToLower()); }
/// <summary> /// Get the requested username from the chatter's message /// </summary> /// <param name="chatter"></param> /// <returns></returns> protected string ParseChatterMessageUsername(TwitchChatter chatter) { if (chatter.Message.IndexOf("@") > 0) { return(chatter.Message.Substring(chatter.Message.IndexOf("@") + 1)); } return(chatter.Message.Substring(chatter.Message.IndexOf(" ") + 1)); }
/// <summary> /// Bot-specific timeout on a user for a set amount of time /// </summary> /// <param name="chatter"></param> public async Task CmdAddTimeout(TwitchChatter chatter) { try { if (chatter.Message.StartsWith("!addtimeout @")) { _irc.SendPublicChatMessage("I cannot make a user not talk to me without this format '!addtimeout [seconds] @[username]'"); } else if (chatter.Message.ToLower().Contains(_botConfig.Broadcaster.ToLower())) { _irc.SendPublicChatMessage($"I cannot betray @{_botConfig.Broadcaster} by not allowing him to communicate with me @{chatter.Username}"); } else if (chatter.Message.ToLower().Contains(_botConfig.BotName.ToLower())) { _irc.SendPublicChatMessage($"You can't time me out @{chatter.Username} PowerUpL Jebaited PowerUpR"); } else { int indexAction = chatter.Message.IndexOf(" "); string recipient = chatter.Message.Substring(chatter.Message.IndexOf("@") + 1).ToLower(); double seconds = -1; bool isValidTimeout = double.TryParse(chatter.Message.Substring(indexAction, chatter.Message.IndexOf("@") - indexAction - 1), out seconds); if (!isValidTimeout || seconds < 0.00) { _irc.SendPublicChatMessage("The timeout amount wasn't accepted. Please try again with positive seconds only"); } else if (seconds < 15.00) { _irc.SendPublicChatMessage("The duration needs to be at least 15 seconds long. Please try again"); } else { DateTime timeoutExpiration = await _timeout.AddTimeout(recipient, _broadcasterId, seconds, _botConfig.TwitchBotApiLink); string response = $"I'm told not to talk to you until {timeoutExpiration.ToLocalTime()} "; if (timeoutExpiration.ToLocalTime().IsDaylightSavingTime()) { response += $"({TimeZone.CurrentTimeZone.DaylightName})"; } else { response += $"({TimeZone.CurrentTimeZone.StandardName})"; } _irc.SendPublicChatMessage($"{response} @{recipient}"); } } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "CmdMod", "CmdAddTimeout(TwitchChatter)", false, "!addtimeout"); } }
/// <summary> /// Updates the game being played on the Twitch channel /// </summary> /// <param name="chatter"></param> /// <param name="hasTwitterInfo">Check for Twitter credentials</param> public async Task CmdUpdateGame(TwitchChatter chatter, bool hasTwitterInfo) { try { // Get game from command parameter string game = chatter.Message.Substring(chatter.Message.IndexOf(" ") + 1); // Send HTTP method PUT to base URI in order to change the game RestClient client = new RestClient("https://api.twitch.tv/kraken/channels/" + _broadcasterInstance.TwitchId); RestRequest request = new RestRequest(Method.PUT); request.AddHeader("Cache-Control", "no-cache"); request.AddHeader("Content-Type", "application/json"); request.AddHeader("Authorization", "OAuth " + _botConfig.TwitchAccessToken); request.AddHeader("Accept", "application/vnd.twitchtv.v5+json"); request.AddHeader("Client-ID", _botConfig.TwitchClientId); request.AddParameter("application/json", "{\"channel\":{\"game\":\"" + game + "\"}}", ParameterType.RequestBody); IRestResponse response = null; try { response = await client.ExecuteTaskAsync <Task>(request); string statResponse = response.StatusCode.ToString(); if (statResponse.Contains("OK")) { _irc.SendPublicChatMessage($"Twitch channel game status updated to \"{game}\""); if (_botConfig.EnableTweets && hasTwitterInfo) { Console.WriteLine(_twitter.SendTweet($"Just switched to \"{game}\" on " + $"twitch.tv/{_broadcasterInstance.Username}")); } await Threads.ChatReminder.RefreshReminders(); } else { Console.WriteLine(response.Content); } } catch (WebException ex) { if (((HttpWebResponse)ex.Response).StatusCode == HttpStatusCode.BadRequest) { Console.WriteLine("Error 400 detected!!"); } response = (IRestResponse)ex.Response; Console.WriteLine("Error: " + response); } } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "CmdMod", "CmdUpdateGame(TwitchChatter, bool)", false, "!updategame"); } }
/// <summary> /// Tell the stream the specified moderator will be AFK /// </summary> /// <param name="chatter"></param> public async void CmdModAfk(TwitchChatter chatter) { try { _irc.SendPublicChatMessage($"@{chatter.DisplayName} is going AFK @{_botConfig.Broadcaster}! SwiftRage"); } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "CmdMod", "CmdModAfk(string)", false, "!modafk"); } }
/// <summary> /// Tell the stream the specified moderator is back /// </summary> /// <param name="chatter"></param> public async void CmdModBack(TwitchChatter chatter) { try { _irc.SendPublicChatMessage($"@{chatter.DisplayName} is back @{_botConfig.Broadcaster}! BlessRNG"); } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "CmdMod", "CmdModBack(string)", false, "!modback"); } }
public string PopJoin(TwitchChatter chatter) { if (_joinStreamerList.Count == 0) { return($"Queue is empty @{chatter.DisplayName}"); } else { string poppedUser = _joinStreamerList.Dequeue(); return($"{poppedUser} has been removed from the queue @{chatter.DisplayName}"); } }
public async void ClearMessage(TwitchChatter chatter) { try { SendIrcMessage(":" + username + "!" + username + "@" + username + ".tmi.twitch.tv PRIVMSG #" + channel + " :/delete " + chatter.MessageId); } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "IrcClient", "ClearMessage(TwitchChatter)", false); } }
/// <summary> /// Display the current game/category for the Twitch channel /// </summary> /// <param name="chatter"></param> /// <returns></returns> private async Task <DateTime> ShowCurrentTwitchGameAsync(TwitchChatter chatter) { try { _irc.SendPublicChatMessage($"We're currently playing \"{TwitchStreamStatus.CurrentCategory}\" @{chatter.DisplayName}"); } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "TwitchChannelFeature", "ShowCurrentTwitchGame(TwitchChatter)", false, "!game"); } return(DateTime.Now); }
private async Task <DateTime> PopJoinAsync(TwitchChatter chatter) { try { _joinStreamerInstance.PopJoin(chatter); } catch (Exception ex) { await _errHndlrInstance.LogError(ex, "JoinStreamerFeature", "PopJoin(TwitchChatter)", false, "!popjoin"); } return(DateTime.Now); }