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 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 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) { 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) { 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) { 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) { 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 TwitchCommandClient( ILogger logger, IKernel kernel, IBotServer game, IMessageBus messageBus, ITwitchMessageFormatter messageFormatter, ITwitchCommandController commandHandler, ITwitchCredentialsProvider credentialsProvider, ITwitchPubSubManager pubSubManager) { this.logger = logger; this.kernel = kernel; this.game = game; this.messageBus = messageBus; this.messageFormatter = messageFormatter; this.commandHandler = commandHandler; this.credentialsProvider = credentialsProvider; this.pubSubManager = pubSubManager; //// For the time being, pubsub will be disabled as it needs actual token for the person that wants to use it? worked in the old bot. but not here. Wutfacers //// ugh... //this.messageBus.Subscribe<string>("streamer_userid_acquired", userid => //{ // ListenForChannelPoints(logger, userid); //}); this.messageBus.Subscribe <PubSubToken>("pubsub", OnPubSubTokenReceived); CreateTwitchClient(); }
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 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) { 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 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 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) { 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 IRavenfallConnection Get(IBotServer server, TcpClient client) { return(new RavenfallConnection( logger, kernel, server, playerProvider, messageBus, new RavenfallGameClientConnection(client, logger))); }
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 RavenfallGameSession( IBotServer server, Guid id, string userId, string name, DateTime created) { this.playerProvider = new PlayerProvider(); this.server = server; this.Id = id; this.UserId = userId; this.Name = name; this.Created = created; }
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 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(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 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 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 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); } } }
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) || !cmd.Arguments.Trim().Contains(" ")) { twitch.Broadcast(channel, cmd.Sender.Username, Localization.TRADE_NO_ARG, cmd.Command); return; } await connection.BuyItemAsync(player, cmd.Arguments); } } }
public override async Task HandleAsync(IBotServer game, ITwitchCommandClient twitch, ICommand cmd) { var session = game.GetSession(cmd.Channel); if (session == null) { return; } // client might not accept a leave. //session.Leave(cmd.Sender.UserId); var connection = game.GetConnection(session); if (connection != null) { var player = session.Get(cmd.Sender); if (player != null) { await connection.LeaveAsync(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.IsNullOrWhiteSpace(cmd.Arguments)) { //twitch.Broadcast(cmd.Sender.Username, "To duel a player you need to specify their name. ex: '!duel JohnDoe', to accept or decline a duel request use '!duel accept' or '!duel decline'. You may also cancel an ongoing request by using '!duel cancel'"); return; } var sub = cmd.Arguments?.Trim(); if (sub.Equals("cancel", StringComparison.InvariantCultureIgnoreCase)) { await connection.CancelDuelRequestAsync(player); } else if (sub.Equals("accept", StringComparison.InvariantCultureIgnoreCase)) { await connection.AcceptDuelRequestAsync(player); } else if (sub.Equals("decline", StringComparison.InvariantCultureIgnoreCase)) { await connection.DeclineDuelRequestAsync(player); } else { await connection.DuelRequestAsync(player, session.GetUserByName(sub)); } } } }