public override Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; twitch.SendChatMessage(channel, "No help available at this time."); return(Task.CompletedTask); }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { if (!cmd.Sender.IsBroadcaster && !cmd.Sender.IsModerator && !cmd.Sender.IsSubscriber) { twitch.Broadcast(channel, cmd.Sender.Username, Localization.OBSERVE_PERM); return; } var targetPlayerName = cmd.Arguments?.Trim(); var player = string.IsNullOrEmpty(targetPlayerName) ? session.Get(cmd.Sender) : session.GetUserByName(targetPlayerName); await connection.ObservePlayerAsync(player); } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); if (player == null) { return; } var pet = cmd.Arguments?.ToLower(); if (string.IsNullOrEmpty(pet)) { await connection.GetPetAsync(player); return; } await connection.SetPetAsync(player, pet); } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); if (string.IsNullOrEmpty(cmd.Arguments)) { await connection.JoinDungeonAsync(player); return; } else if (cmd.Arguments.Contains("stop", System.StringComparison.OrdinalIgnoreCase)) { if (player.IsBroadcaster || player.IsModerator) { await connection.StopDungeonAsync(player); } } else { await connection.DungeonStartAsync(player); } } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { if (!string.IsNullOrEmpty(cmd.Arguments) && (cmd.Sender.IsBroadcaster || cmd.Sender.IsModerator)) { var player = session.GetUserByName(cmd.Arguments); if (player != null) { await connection.UnstuckAsync(player); } } else { var player = session.Get(cmd.Sender); await connection.UnstuckAsync(player); } } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); if (string.IsNullOrEmpty(cmd.Arguments)) { await connection.ActivateTicTacToeAsync(player); return; } if (cmd.Arguments.Trim().Equals("reset", System.StringComparison.OrdinalIgnoreCase)) { await connection.ResetTicTacToeAsync(player); return; } if (int.TryParse(cmd.Arguments.Trim(), out var num)) { await connection.PlayTicTacToeAsync(player, num); } } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var targetPlayerName = cmd.Arguments?.Trim(); Player player = null; if ((cmd.Sender.IsBroadcaster || cmd.Sender.IsModerator) && !string.IsNullOrEmpty(targetPlayerName)) { player = session.GetUserByName(targetPlayerName); } else { player = session.Get(cmd.Sender); } await connection.TurnIntoMonsterAsync(player); } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { if (!cmd.Sender.IsBroadcaster && !cmd.Sender.IsModerator) { twitch.Broadcast(channel, cmd.Sender.Username, Localization.KICK_PERM); return; } var targetPlayerName = cmd.Arguments?.Trim(); if (string.IsNullOrEmpty(targetPlayerName)) { twitch.Broadcast(channel, cmd.Sender.Username, Localization.KICK_NO_USER); return; } await connection.KickAsync(session.GetUserByName(targetPlayerName)); } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { if (string.IsNullOrEmpty(cmd.Arguments)) { twitch.Broadcast(channel, cmd.Sender.Username, Localization.VALUE_NO_ARG, cmd.Command); return; } var player = session.Get(cmd.Sender); if (cmd.Arguments.Contains("helm", StringComparison.OrdinalIgnoreCase)) { await connection.ToggleHelmetAsync(player); } else if (cmd.Arguments.Contains("pet", StringComparison.OrdinalIgnoreCase)) { await connection.TogglePetAsync(player); } else { twitch.Broadcast(channel, cmd.Sender.Username, Localization.TOGGLE_INVALID, cmd.Arguments); } } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); var destination = cmd.Arguments?.ToLower(); if (string.IsNullOrEmpty(destination)) { await connection.EmbarkFerryAsync(player); return; } if (destination.StartsWith("stop")) { await connection.DisembarkFerryAsync(player); return; } await connection.TravelAsync(player, destination); } } }
public Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ChatMessage msg) { var channel = msg.Channel; var session = game.GetSession(channel); if (session != null) { session.SendChatMessage(msg.Username, msg.Message); if (msg.Bits > 0) { this.messageBus.Send( nameof(ROBot.Core.Twitch.TwitchCheer), new ROBot.Core.Twitch.TwitchCheer( msg.Channel, msg.Id, msg.Username, msg.DisplayName, msg.IsModerator, msg.IsSubscriber, msg.IsVip, msg.Bits) ); } } return(Task.CompletedTask); }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var destination = cmd.Arguments?.ToLower(); if (string.IsNullOrEmpty(destination)) { twitch.Broadcast(channel, cmd.Sender.Username, Localization.TRAVEL_NO_ARG); return; } var player = session.Get(cmd.Sender); if (player != null) { await connection.TravelAsync(player, destination); } } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); var numOfSubs = 1; if (!string.IsNullOrEmpty(cmd.Arguments)) { int.TryParse(cmd.Arguments, out numOfSubs); } if (numOfSubs < 15) { return; } await connection.SetExpMultiplierLimitAsync(player, numOfSubs); } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); if (player == null) { return; } var item = cmd.Arguments?.ToLower(); if (string.IsNullOrEmpty(item)) { twitch.Broadcast(channel, cmd.Sender.Username, "You have to use !equip <item name> or !equip all for equipping your best items."); return; } await connection.EquipAsync(player, item); } } }
public override Task HandleAsync(ITwitchCommandClient client, ChatCommand cmd) { var channel = cmd.ChatMessage.Channel; client.SendChatMessage(channel, "No help available at this time."); return(Task.CompletedTask); }
public StreamBotApp( ILogger logger, IRavenfallServerConnection ravenfall, ITwitchCommandClient twitch // IYouTubeCommandClient youtube ) { this.logger = logger; this.ravenfall = ravenfall; this.twitch = twitch; }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); if (GetCombatTypeFromString(cmd.Command) != -1) { await connection.SendPlayerTaskAsync(player, PlayerTask.Fighting, cmd.Command); return; } var commandSkillTarget = GetSkillTypeFromString(cmd.Command); if (commandSkillTarget != -1) { await connection.SendPlayerTaskAsync(player, (PlayerTask)commandSkillTarget, cmd.Command); return; } var arg = cmd.Arguments?.ToLower(); var skill = arg?.Split(' ').LastOrDefault(); if (string.IsNullOrEmpty(skill)) { twitch.Broadcast(channel, cmd.Sender.Username, Localization.TRAIN_NO_ARG, string.Join(", ", trainableSkills)); return; } if (GetCombatTypeFromString(skill) != -1) { await connection.SendPlayerTaskAsync(player, PlayerTask.Fighting, skill); } else { var value = GetSkillTypeFromString(skill); if (value == -1) { twitch.Broadcast(channel, cmd.Sender.Username, Localization.TRAIN_INVALID, skill); } else { await connection.SendPlayerTaskAsync(player, (PlayerTask)value, skill); } } } } }
private async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var handler = FindHandler(cmd.Command); if (handler == null) { logger.LogInformation("HandleAsync::Unknown Command: " + cmd.Command + " - " + cmd.Arguments); return; } await handler.HandleAsync(game, twitch, cmd); }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Join(cmd.Sender, cmd.Arguments); await connection.JoinAsync(player); } } }
public StreamBotApp( ILogger logger, IGameSessionManager sessionManager, IBotServer ravenfall, ITwitchCommandClient twitch) { this.logger = logger; this.sessionManager = sessionManager; this.botServer = ravenfall; this.twitch = twitch; sessionManager.SessionStarted += OnSessionStarted; sessionManager.SessionEnded += OnSessionEnded; sessionManager.SessionUpdated += OnSessionUpdated; }
public async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ChatMessage message) { if (messageHandler == null) { messageHandler = ioc.Resolve <ITwitchChatMessageHandler>(); } if (messageHandler == null) { logger.LogInformation("HandleMessage: No message handler available."); return; } await messageHandler.HandleAsync(game, twitch, message); }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); await connection.RequestPlayerResourcesAsync(player); } } }
public async Task HandleAsync(IRavenfallServerConnection game, ITwitchCommandClient twitch, ChatCommand command) { var key = command.CommandText.ToLower(); ITwitchCommandHandler handler = null; if (handlerLookup.TryGetValue(key, out var handlerType)) { handler = ioc.Resolve(handlerType) as ITwitchCommandHandler; } if (handler == null) { logger.LogInformation("HandleCommand::Unknown Command: " + command.CommandIdentifier + ": " + command.CommandText); return; } await handler.HandleAsync(game, twitch, command); }
public async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ChatCommand command) { var key = command.CommandText.ToLower(); var session = game.GetSession(command.ChatMessage.Channel); var argString = !string.IsNullOrEmpty(command.ArgumentsAsString) ? " (args: " + command.ArgumentsAsString + ") " : ""; if (session != null) { logger.LogDebug("[" + session.Name + "] Command: " + key + argString + " from " + command.ChatMessage.Username); } else { logger.LogDebug("Twitch Command Received: " + key + argString + " from " + command.ChatMessage.Username + " in #" + command.ChatMessage.Channel); } await HandleAsync(game, twitch, new TwitchCommand(command)); }
public async Task HandleAsync(ITwitchCommandClient listener, ChatCommand command) { var key = command.CommandText.ToLower(); ITwitchCommandHandler handler = null; if (handlerLookup.TryGetValue(key, out var handlerType)) { handler = this.ioc.Resolve(handlerType) as ITwitchCommandHandler; } if (handler == null) { logger.WriteError("HandleCommand::Unknown Command: " + command.CommandIdentifier + ": " + command.CommandText); return; } await handler.HandleAsync(listener, command); }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); if (player != null) { await connection.SetTimeOfDayAsync(player, 230, 30); } } } }
public override Task HandleAsync(IRavenfallServerConnection game, ITwitchCommandClient twitch, ChatCommand cmd) { var channel = cmd.ChatMessage.Channel; var session = game.GetSession(channel); var userId = cmd.ChatMessage.UserId; if (session.Contains(userId)) { session.Leave(userId); twitch.SendChatMessage(channel, $"@{cmd.ChatMessage.Username}, leaving game..."); } else { twitch.SendChatMessage(channel, $"@{cmd.ChatMessage.Username}, you're not currently playing. Use !join to start playing."); } return(Task.CompletedTask); }
public override Task HandleAsync(IRavenfallServerConnection game, ITwitchCommandClient twitch, ChatCommand cmd) { var channel = cmd.ChatMessage.Channel; var session = game.GetSession(channel); var userId = cmd.ChatMessage.UserId; if (session.Contains(userId)) { twitch.SendChatMessage(channel, $"@{cmd.ChatMessage.Username}, you're already playing."); } else { session.Join(cmd.ChatMessage.Username, cmd.ChatMessage.UserId, null); twitch.SendChatMessage(channel, $"@{cmd.ChatMessage.Username}, joining game..."); } return(Task.CompletedTask); }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); if (!string.IsNullOrEmpty(cmd.Arguments)) { player = session.GetUserByName(cmd.Arguments); } await connection.InspectPlayerAsync(player); } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var channel = cmd.Channel; var session = game.GetSession(channel); if (session != null) { var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); if (string.IsNullOrEmpty(cmd.Arguments)) { twitch.Broadcast(channel, cmd.Sender.Username, Localization.REDEEM_NO_ARG); return; } await connection.RedeemStreamerTokenAsync(player, cmd.Arguments); } } }