示例#1
0
        private void DrawHeader()
        {
            GameDetails gameDetails = _manager.DetailsOf(GameId);

            string gameName      = GameId;
            string playerCounter = $"**{Players.Count:##,0}** {Format.TryPluralize("player", Players.Count)}";

            if (gameDetails != null)
            {
                gameName      = gameDetails.Name;
                playerCounter = $"**{Players.Count:##,0}**/**{gameDetails.PlayerLimit:##,0}** {Format.TryPluralize("player", gameDetails.PlayerLimit)}";
            }

            GetBroadcast(GameState.Waiting).Content
            .GetComponent(LobbyVars.Header)
            .Draw(Name, Id, Format.Title(gameName, gameDetails?.Icon), playerCounter);
        }
示例#2
0
        public async Task ViewChangelogAsync()
        {
            IChannel channel = Context.Client.GetChannel(Context.Data.Data.LogChannelId);

            if (channel is IMessageChannel mChannel)
            {
                IEnumerable <IMessage> messages = await mChannel.GetMessagesAsync(1).FlattenAsync();

                IMessage message = messages.FirstOrDefault();

                if (message != null)
                {
                    await message.CloneAsync(Context.Channel);

                    return;
                }
            }

            await Context.Channel.SendMessageAsync(Format.Warning("Unable to find a previous changelog to reference."));
        }
示例#3
0
        public async Task SetOptionAsync(string name, [Name("value")] string unparsed)
        {
            PropertyInfo option = ClassHelper.GetProperty(Context.Account.Config, name);

            if (option == null)
            {
                await Context.Channel.SendMessageAsync(Format.Warning("Unknown option specified."));

                return;
            }

            Type type     = Context.Account.Config.GetOptionType(name);
            var  clamp    = option.GetCustomAttribute <ClampAttribute>();
            bool useFlags = type.GetCustomAttribute <FlagsAttribute>() != null;

            var panel = new StringBuilder();

            panel.AppendLine($"> **{Context.Account.Config.GetOptionName(name)}**");

            switch (unparsed)
            {
            case "--default":
                Context.Account.Config.SetOptionDefault(name);
                panel.AppendLine("> The specified option has been reset.");
                break;

            case "--min":
            {
                if (type != typeof(int))
                {
                    panel.AppendLine("> This method can only be used on a `Number` with a specified minimum range.");
                }
                else if (clamp == null || !clamp.HasMin)
                {
                    panel.AppendLine("> This `Number` does not have a specified minimum range.");
                }
                else
                {
                    Context.Account.Config.SetOption(name, clamp.Min);
                    panel.AppendLine("> The specified option has been set to its lowest possible value.");
                }

                break;
            }

            case "--max":
            {
                if (type != typeof(int))
                {
                    panel.AppendLine("> This method can only be used on a `Number` with a specified maximum range.");
                }
                else if (clamp == null)
                {
                    panel.AppendLine("> This `Number` does not have a specified maximum range.");
                }
                else
                {
                    Context.Account.Config.SetOption(name, clamp.Max);
                    panel.AppendLine("> The specified option has been set to its highest possible value.");
                }

                break;
            }

            case "--none":
            {
                if (!type.IsEnum || !useFlags)
                {
                    panel.AppendLine("> This method can only be used on a `Flag`.");
                }
                else if (!Enum.TryParse(type, "0", out object e))
                {
                    panel.AppendLine("> An error occurred while attempted to clear all flags.");
                }
                else
                {
                    Context.Account.Config.SetOption(name, e);
                    panel.AppendLine("> Cleared all flags.");
                }

                break;
            }

            case "--all":
            {
                if (!type.IsEnum || !useFlags)
                {
                    panel.AppendLine("> This method can only be used on a `Flag`.");
                }
                else if (!Enum.TryParse(type, $"{type.GetEnumValues().Cast<Enum>().Select(Convert.ToInt64).Sum()}", out object e))
                {
                    panel.AppendLine("> An error occurred while attempting to activate all flags.");
                }
                else
                {
                    Context.Account.Config.SetOption(name, e);
                    panel.AppendLine("> Activated all flags.");
                }

                break;
            }

            default:
                if (TypeParser.TryParse(type, unparsed, out object result))
                {
                    if (type.IsEnum)
                    {
                        long flagValue = Convert.ToInt64(result);
                        if (flagValue < 0)
                        {
                            panel.AppendLine("> Flags cannot be negative.");
                            break;
                        }

                        long partialSum = EnumUtils.GetFlags(result).Select(Convert.ToInt64).Sum();

                        if (flagValue > 0)
                        {
                            if (flagValue - partialSum > 0)
                            {
                                panel.AppendLine("> The flag summation contains an invalid flag.");
                                break;
                            }
                        }
                    }
                    if (type == typeof(string) && result is string s)
                    {
                        if (s.Contains("\n"))
                        {
                            panel.AppendLine("> The specified value cannot contain any line breaks.");
                            break;
                        }

                        if (clamp != null)
                        {
                            if (s.Length > clamp.Max)
                            {
                                panel.AppendLine($"> The specified value cannot be larger than `{clamp.Max}`.");
                                break;
                            }
                        }
                    }
                    if (type == typeof(int) && result is int i)
                    {
                        if (clamp != null)
                        {
                            if (clamp.HasMin && (i < clamp.Min || i > clamp.Max))
                            {
                                panel.AppendLine($"> The specified value is out of range (`{clamp.Min} to {clamp.Max}`).");
                                break;
                            }

                            if (i > clamp.Max)
                            {
                                panel.AppendLine($"> The specified value cannot be larger than `{clamp.Max}`.");
                                break;
                            }
                        }
                    }

                    Context.Account.Config.SetOption(name, result);
                    panel.Append($"> The specified value has been set to `{Context.Account.Config.WriteOptionValue(result)}`.");
                }
                else
                {
                    panel.AppendLine("> The specified value could not be parsed.");

                    if (type.IsEnum)
                    {
                        panel.AppendLine();
                        List <string> names  = type.GetEnumNames().ToList();
                        List <long>   values = type.GetEnumValues().Cast <object>().Select(Convert.ToInt64).ToList();
                        List <string> groups = names.Join(values,
                                                          a => names.IndexOf(a),
                                                          b => values.IndexOf(b),
                                                          (a, b) => $"{a} = {b}")
                                               .ToList();

                        if (groups.Any())
                        {
                            panel.AppendLine($"> **Values**\n```cs");
                            panel.AppendJoin(",\n", groups);
                            panel.AppendLine("```");
                        }
                    }
                }

                break;
            }

            await Context.Channel.SendMessageAsync(panel.ToString());
        }
示例#4
0
        // This is only invoked if the ID is either the Host or the Participant.
        public override async Task <MatchResult> InvokeAsync(SocketMessage message)
        {
            // gets the account that executed this.
            var account = GetAccount(message.Author.Id);

            // Get the input from the message
            string input = message.Content;

            // CANCEL: This cancels the current trade, regardless of who executed it.
            if (input == "cancel")
            {
                await SetStateAsync(TradeState.Cancel);
                await UpdateMessageAsync(WriteOnCancel(account));

                return(MatchResult.Success);
            }

            // If the current invoker is not the current speaker, ignore their inputs
            if (CurrentId.HasValue)
            {
                if (CurrentId.Value != account.Id)
                {
                    return(MatchResult.Continue);
                }
            }

            switch (State)
            {
            case TradeState.Invite:
                // ACCEPT
                if (input == "accept" && account.Id == Participant.Id)
                {
                    // If the user accepted the trade invitation, go to the base trade menu.
                    await SetStateAsync(TradeState.Menu, $"> ☑️ **{Participant.Username}** has agreed to trade.");

                    Participant.CanTrade = false;
                    return(MatchResult.Continue);
                }

                // DECLINE
                if (input == "decline" && account.Id == Participant.Id)
                {
                    await SetStateAsync(TradeState.Cancel);
                    await UpdateMessageAsync(WriteOnCancel(account));

                    return(MatchResult.Success);
                }
                break;

            case TradeState.Menu:
                // ACCEPT: This marks the user who executed it that they accepted their end of the trade.
                // If both users accept, then the trade goes through. Take all specified items from both, swap, and give both the other's items.
                if (input == "ready")
                {
                    if (IsOfferEmpty())
                    {
                        await SetStateAsync(TradeState.Menu, Format.Warning("There aren't any items specified!"));

                        return(MatchResult.Continue);
                    }

                    if (CanStartTrade())
                    {
                        Trade();
                        await SetStateAsync(TradeState.Success);

                        return(MatchResult.Success);
                    }

                    MarkAsReady(account.Id);
                    await SetStateAsync(TradeState.Menu);

                    return(MatchResult.Continue);
                }

                if (input == "inventory")
                {
                    // If someone is already inspecting their backpack, ignore input.
                    if (CurrentId.HasValue)
                    {
                        return(MatchResult.Continue);
                    }

                    CurrentId = account.Id;
                    await SetStateAsync(TradeState.Inventory);

                    return(MatchResult.Continue);
                }
                break;

            case TradeState.Inventory:
                // BACK: Used by the current invoker to return to the menu.
                if (input == "back")
                {
                    CurrentId = null;
                    await SetStateAsync(TradeState.Menu);

                    return(MatchResult.Continue);
                }

                // TODO: Handle unique item ID when trading.

                // Check if the specified item exists in the invoker inventory
                if (!ItemHelper.HasItem(account, input))
                {
                    await SetStateAsync(TradeState.Inventory, Format.Warning("An invalid item ID was specified."));

                    return(MatchResult.Continue);
                }

                // If the specified item was already selected, remove it from their trade.
                if (GetCurrentItems().ContainsKey(input))
                {
                    RemoveItemFromCurrent(input);
                    await SetStateAsync(TradeState.Inventory, "> 📤 Removed the specified item from your offer.");

                    HostReady        = false;
                    ParticipantReady = false;
                    return(MatchResult.Continue);
                }

                ItemData selectedItem = ItemHelper.DataOf(account, input);

                if (!ItemHelper.CanTrade(input, selectedItem))
                {
                    await SetStateAsync(TradeState.Inventory, Format.Warning("This item is unavailable for trading."));

                    return(MatchResult.Continue);
                }

                AddItemToCurrent(input);
                await SetStateAsync(TradeState.Inventory, "> 📥 Added the specified item to your offer.");

                HostReady        = false;
                ParticipantReady = false;
                return(MatchResult.Continue);
            }

            return(MatchResult.Continue);
        }