Beispiel #1
0
 private string BuildOperationOutput(IViewOperation <IViewItem> operation)
 {
     return(string.Join("", operation.Data.Select((viewItem) => _viewBuilder.Build(viewItem))));
 }
Beispiel #2
0
 public MudLikeViewBuilder AddOperation(IViewOperation <IViewItem> operation)
 {
     _operations.Add(operation);
     return(this);
 }
Beispiel #3
0
        private Task ProcessListSpawnersAsync(IProcessorData <CommandModel> request, IPlayer player)
        {
            request.Handled = true;

            Parser.Default.ParseArguments <ListSpawnerParserOptions>(request.Data.StringFrom(2).Split(' '))
            .WithParsed(async(parsed) =>
            {
                var validSpawnTypes = new List <string>()
                {
                    "item", "entity"
                };


                var match = validSpawnTypes.FirstOrDefault(s => s == parsed.SpawnType);
                if (match != null)
                {
                    validSpawnTypes.RemoveAll(s => s != match);
                }


                var viewbuilder = MudLikeViewBuilder.Start();

                var partial = Game.Spawners.Cast <GridSpawner>().Where(spawner => spawner.Map == player.Map).ToList();
                foreach (var spawnType in validSpawnTypes)
                {
                    IViewOperation <IViewItem> operation = null;
                    var opBuilder = MudLikeOperationBuilder.Start();
                    opBuilder
                    .AddTextLine(spawnType, TextColor.Olive)
                    .AddTextLine("------------------------------", TextColor.Olive);

                    switch (spawnType)
                    {
                    case "entity":
                        var entityMatches = partial.Where(spawner => spawner.SpawnType == Core.Game.SpawnType.Entity).Select(s => s.EntityId).ToList();
                        var entities      = Game.Entities.Where(e => entityMatches.Contains(e.Id)).ToList();
                        foreach (GridEntity entity in entities)
                        {
                            opBuilder
                            .AddText($"{entity.Id} ", TextColor.Aqua)
                            .AddText($"{entity.Name} ");


                            entity.Stats.ToList().ForEach(stat =>
                            {
                                opBuilder
                                .AddText($"{stat.Name} ", TextColor.Gray)
                                .AddText($"{stat.Value} ")
                                ;
                            });
                            opBuilder.AddLineBreak();
                        }

                        operation = opBuilder.Build();

                        break;

                    case "item":
                        var itemMatches = partial.Where(spawner => spawner.SpawnType == Core.Game.SpawnType.Item);
                        var items       = Game.Items.Where(e => itemMatches.Select(i => i.Id).Contains(e.Id)).ToList();

                        foreach (GridItem item in items)
                        {
                            opBuilder
                            .AddText($"{item.Id} ", TextColor.Aqua)
                            .AddText($"{item.Name} ")
                            ;

                            item.Stats.ToList().ForEach(stat =>
                            {
                                opBuilder
                                .AddText($"{stat.Name} ", TextColor.Gray)
                                .AddText($"{stat.Value} ")
                                ;
                            });
                            opBuilder.AddLineBreak();
                        }

                        operation = opBuilder.Build();
                        break;

                    default:
                        break;
                    }

                    if (operation != null)
                    {
                        viewbuilder.AddOperation(operation);
                    }
                }


                await Game.Network.SendViewCommandsToPlayerAsync(player, viewbuilder.Build());
            })
            .WithNotParsed(async(issues) =>
            {
                await Game.Network.SendMessageToPlayerAsync(player, "invalid command - for help type spawner help");
            });

            return(Task.CompletedTask);
        }