private async Task HandleBasicLogoutAsync(IProcessorData <CommandModel> request, IPlayer player) { if (await Game.RemovePlayerAsync(player)) { await Game.Network.SendMessageToPlayerAsync(request.TransportId, "Logged out"); } }
private Task ProcessAddSpawnersAsync(IProcessorData <CommandModel> request, IPlayer player) { request.Handled = true; Parser.Default.ParseArguments <AddSpawnerParserOptions>(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); } if (validSpawnTypes.Count > 1) { validSpawnTypes.RemoveAt(1); } }) .WithNotParsed(async(issues) => { await Game.Network.SendMessageToPlayerAsync(player, "invalid command - for help type spawner help"); }); return(Task.CompletedTask); }
public TestBed(string protocolFilePath, [NotNull] IReportScriptOut reportScriptOut) { Out = reportScriptOut ?? throw new ArgumentNullException(nameof(reportScriptOut)); protocolFilePath = CheckFileExistsInCurrentFolderOrScriptsFolder(protocolFilePath); var protocol = (IAssayPackageProtocol)AssayPackageManager.AssayPackageManager.UnPack(protocolFilePath); if (string.IsNullOrEmpty(protocol.AssayRunDetailsFilePath) || !File.Exists(protocol.AssayRunDetailsFilePath)) { throw new Exception($"The protocol {Path.GetFullPath(protocolFilePath)} is not ready for analysis. Open it in MyAssays Analysis and save, then try again."); } var pluginsInputStorage = new PluginsInputStorage(); pluginsInputStorage.StoreAssayXml(protocol.AssayXml.OuterXml); pluginsInputStorage.LoadRunDetails(protocol.AssayRunDetailsFilePath); pluginsInputStorage.InitialiseTransformInputs(); var analysisLoggerMock = new Mock <IAnalysisLogger>(); _data = AnalysisProcessorData.Load( pluginsInputStorage.ConfigFilePath, pluginsInputStorage.RunDetailsFilePath, pluginsInputStorage.PmcFilePath, pluginsInputStorage.FieldDataFilePath, pluginsInputStorage.AssayFilePath, analysisLoggerMock.Object); In = new ReportInMock(_data); _script = new Script(); ((ScriptBase)_script).Init(In, Out); }
public override async Task LoggedInProcessAsync(IProcessorData <CommandModel> request, IPlayer player) { switch (request.Data.FirstPart) { case "look": await ProcessBasicLook(request, player); break; } await base.LoggedInProcessAsync(request, player); }
public override Task LoggedInProcessAsync(IProcessorData <CommandModel> request, IPlayer player) { switch (request.Data.FirstPart) { case "login": return(Game.Network.SendMessageToPlayerAsync(request.TransportId, $"Already logged in as {player.Name}.")); case "logout": return(HandleBasicLogoutAsync(request, player)); } return(base.LoggedInProcessAsync(request, player)); }
public override async Task LoggedInProcessAsync(IProcessorData <CommandModel> request, IPlayer player) { await base.LoggedInProcessAsync(request, player); switch (request.Data.SecondPart) { case "pickup": await ProcessItemPickupAsync(request, player); break; } }
public override async Task NotLoggedInProcessAsync(IProcessorData <CommandModel> request) { if (request.Data.FirstPart == "register") { if (string.IsNullOrEmpty(request.Data.ThirdPart)) { await Game.Network.SendMessageToPlayerAsync(request.TransportId, $"format: register charactername password"); return; } var startingInventory = new List <IItem>(); var startingStats = new List <IStat>() { new BasicStat("health", 100, 100), new BasicStat("mana", 100, 100), new BasicStat("stamina", 100, 100) }; var username = request.Data.SecondPart; var created = await Game.Store.NewPlayerAsync(Game, new GridPlayer( 0, username, new List <EntityType>() { EntityType.Normal, EntityType.Combat }, new List <IEntityComponent>() { new GridCombatant() }, startingInventory, startingStats, null), pass : request.Data.ThirdPart); if (created != null) { await Game.Network.SendMessageToPlayerAsync(request.TransportId, $"Character {request.Data.SecondPart} created"); } else { await Game.Network.SendMessageToPlayerAsync(request.TransportId, $"Registration rejected"); } return; } if (request.Data.FirstPart != "login" || string.IsNullOrEmpty(request.Data.SecondPart)) { return; } request.Handled = true; await HandleBasicLoginAsync(request); }
public override Task LoggedInProcessAsync(IProcessorData <CommandModel> request, IPlayer player) { switch (request.Data.FirstPart) { case "say": return(ProcessSayAsync(request, player)); case "tell": return(ProcessTellAsync(request, player)); } return(base.LoggedInProcessAsync(request, player)); }
public override Task LoggedInProcessAsync(IProcessorData <CommandModel> request, IPlayer player) { switch (request.Data.SecondPart) { case "list": return(ProcessListSpawnersAsync(request, player)); case "add": return(ProcessAddSpawnersAsync(request, player)); } return(base.LoggedInProcessAsync(request, player)); }
public async Task ProcessAsync(IProcessorData <CommandModel> request) { foreach (var plugin in _commandPlugins) { _logger.LogDebug("ProcessAsync - " + plugin.Name); await plugin.ProcessAsync(request); if (request.Handled) { break; } } }
private Task ProcessItemPickupAsync(IProcessorData <CommandModel> request, IPlayer player) { request.Handled = true; Parser.Default.ParseArguments <ItemPickupParserOptions>(request.Data.StringFrom(2).Split(' ')) .WithParsed(async(parsed) => { var itemName = string.Join(" ", parsed.Name); // take each matching item up to the quantity we requested var mapItems = ( parsed.PickupAny ? player.Map.Items : player.Map.Items.Where(mi => mi.Name.IndexOf(itemName, StringComparison.OrdinalIgnoreCase) >= 0)) .Take(parsed.Quantity) .ToList(); if (mapItems.Count == 0) { await Game.Network.SendMessageToPlayerAsync(player, "Matching item not found"); return; } itemName = mapItems[0].Name; await Game.Network.SendMessageToPlayerAsync(player, $"Looting {itemName} | quantity {mapItems.Count}"); foreach (var i in mapItems) { // double check one last time the item wasn't picked up elsewhere in the time we've been picking up others if (player.Map.Items.Contains(i)) { await player.PickupItemAsync(Game, i); } } var itemView = MudLikeViewBuilder.Start() .AddOperation( MudLikeOperationBuilder.Start("itemlist").AddItems(player.Map.Items).Build()) .Build(); await Game.Network.SendViewCommandsToMapAsync(player.Map, itemView); }) .WithNotParsed(async(issues) => { await Game.Network.SendMessageToPlayerAsync(player, "invalid command(pickup) - for help type item help"); }); return(Task.CompletedTask); }
private Task ProcessBasicAttack(IProcessorData <CommandModel> request, IPlayer player) { request.Handled = true; Parser.Default.ParseArguments <InitiateCombatParserOptions>(request.Data.StringFrom(1).Split(' ')) .WithParsed(async(parsed) => { var entityName = string.Join(" ", parsed.Name); if (!parsed.AttackAny && string.IsNullOrWhiteSpace(entityName)) { await Game.Network.SendMessageToPlayerAsync(player, GetHelp()); return; } GridEntity target = (GridEntity)( parsed.AttackAny ? player.Map.Entities : player.Map.Entities.Where(mi => mi.Name.IndexOf(entityName, StringComparison.OrdinalIgnoreCase) >= 0)) .Skip(parsed.Skip) .FirstOrDefault(); if (target == null) { await Game.Network.SendMessageToPlayerAsync(player, "No matching target found"); return; } entityName = target.Name; if (!target.IsAttackable()) { await Game.Network.SendMessageToPlayerAsync(player, $"{entityName} is not attackable"); return; } var issues = string.Empty; var encounter = await _combatModule.AppendOrNewEncounterAsync((GridEntity)player, target); }) .WithNotParsed(async(issues) => { await Game.Network.SendMessageToPlayerAsync(player, GetHelp()); }) ; return(Task.CompletedTask); }
public override Task LoggedInProcessAsync(IProcessorData <CommandModel> request, IPlayer player) { switch (request.Data.SecondPart) { case "create": return(ProcessCreateAsync(request, player)); case "delete": return(ProcessDeleteAsync(request, player)); case "edit": return(ProcessEditAsync(request, player)); } return(base.LoggedInProcessAsync(request, player)); }
public override async Task LoggedInProcessAsync(IProcessorData <CommandModel> request, IPlayer player) { await base.LoggedInProcessAsync(request, player); switch (request.Data.FirstPart) { case "attack": await ProcessBasicAttack(request, player); break; case "cast": await ProcessBasicCast(request, player); break; } }
public async Task ProcessAsync(IProcessorData <CommandModel> request) { if (!Handles.Any(handleCommand => handleCommand == request.Data.FirstPart)) { return; } var player = Game.Players.GetPlayerByTransportId(request.TransportId); if (player == null) { await NotLoggedInProcessAsync(request); } else { await LoggedInProcessAsync(request, player); } }
private async Task ProcessBasicLook(IProcessorData <CommandModel> request, IPlayer player) { request.Handled = true; if (!string.IsNullOrEmpty(request.Data.SecondPart)) { await Game.Network.SendMessageToPlayerAsync(player, "Complex look not yet supported. Processing without arguments."); } var mapView = MudLikeOperationBuilder.Start() .AddWorldDate(Game.World.Time.WorldTime) .AddMap((GridMap)player.Map, includePlayers: true) .Build(); var itemsView = MudLikeOperationBuilder.Start("itemlist").AddItems(player.Map.Items) .Build(); var entitiesUpdate = MudLikeOperationBuilder.Start(MudContainers.EntityList.ToString()).AddEntities(player.Map.Entities) .Build(); await Game.Network.SendViewCommandsToPlayerAsync(player, MudLikeViewBuilder.Start().AddOperation(mapView).AddOperation(itemsView).AddOperation(entitiesUpdate).Build()); }
private async Task HandleBasicLoginAsync(IProcessorData <CommandModel> request) { var player = (GridPlayer)await Game.Store.LoadPlayerAsync(Game, request.Data.SecondPart, request.Data.ThirdPart); if (player == null) { await Game.Network.SendMessageToPlayerAsync(request.TransportId, $"Login was rejected"); return; } player.TransportId = request.TransportId; if (await Game.AddPlayerAsync((IPlayer)player)) { await Game.Network.SendMessageToPlayerAsync(request.TransportId, $"Logged in as {request.Data.SecondPart} -- PlayerCount: {Game.Players.Count}"); } else { await Game.Network.SendMessageToPlayerAsync(request.TransportId, $"Login was rejected"); } }
private async Task ProcessTellAsync(IProcessorData <CommandModel> request, IPlayer player) { request.Handled = true; var destinationPlayer = Game.Players.GetPlayerByName(request.Data.SecondPart); if (destinationPlayer == null) { await Game.Network.SendMessageToPlayerAsync(request.TransportId, $"Player not found."); return; } if (destinationPlayer == player) { await Game.Network.SendMessageToPlayerAsync(request.TransportId, $"You tell yourself something really stupid."); return; } var message = request.Data.StringFrom(2); await Game.Network.SendMessageToPlayerAsync(player, $"You tell {destinationPlayer.Name}, {message}"); await Game.Network.SendMessageToPlayerAsync(destinationPlayer, $"{player.Name} tells you, {message}"); }
private Task ProcessDeleteAsync(IProcessorData <CommandModel> request, IPlayer player) { request.Handled = true; Parser.Default.ParseArguments <DeleteMapParserOptions>(request.Data.StringFrom(2).Split(' ')) .WithParsed(async(parsed) => { if (parsed.Id == null) { await Game.Network.SendMessageToPlayerAsync(player, "direction or location xyz parameters are required"); return; } if (parsed.Id.HasValue) { var map = Game.World.Maps.FirstOrDefault(m => m.Id == parsed.Id); if (map == null) { await Game.Network.SendMessageToPlayerAsync(player, $"map with id {parsed.Id.GetValueOrDefault(0)} was not found"); return; } // update the map exits that were connected to this one. if (parsed.Cleanup && map.Exits.Count > 0) { foreach (var exit in map.Exits) { var cleanupLocation = GetNextLocation(map.Location, exit); var cleanupMap = Game.World.Maps.FirstOrDefault(m => m.Location.X == cleanupLocation.X && m.Location.Y == cleanupLocation.Y && m.Location.Z == cleanupLocation.Z); if (cleanupMap == null || !cleanupMap.Exits.Any(o => o == exit)) { break; } switch (exit) { case Exits.North: cleanupMap.RemoveExit(Exits.South); break; case Exits.East: cleanupMap.RemoveExit(Exits.West); break; case Exits.South: cleanupMap.RemoveExit(Exits.North); break; case Exits.West: cleanupMap.RemoveExit(Exits.East); break; case Exits.Up: cleanupMap.RemoveExit(Exits.Down); break; case Exits.Down: cleanupMap.RemoveExit(Exits.Up); break; } await Game.Store.UpdateMapsAsync(Game, new List <IMap>() { cleanupMap }); } } await Game.World.RemoveMapAsync(map); await Game.Store.DeleteMapsAsync(Game, new List <IMap>() { map }); await Game.Network.SendMessageToPlayerAsync(player, $"Removed map. HadExits[{map.Exits.Count > 0}]"); } }) .WithNotParsed(async(issues) => { await Game.Network.SendMessageToPlayerAsync(player, "invalid command - for help type map help"); }); return(Task.CompletedTask); }
public virtual Task LoggedInProcessAsync(IProcessorData <CommandModel> request, IPlayer player) { return(Task.CompletedTask); }
public virtual Task NotLoggedInProcessAsync(IProcessorData <CommandModel> request) { return(Task.CompletedTask); }
public override async Task LoggedInProcessAsync(IProcessorData <CommandModel> request, IPlayer player) { var currentMap = (GridMap)player.Map; var currentGridLocation = currentMap.Location; var exit = Exits.None; switch (request.Data.FirstPart) { case "n": case "north": exit = Exits.North; break; case "e": case "east": exit = Exits.East; break; case "s": case "south": exit = Exits.South; break; case "w": case "west": exit = Exits.West; break; case "u": case "up": exit = Exits.Up; break; case "d": case "down": exit = Exits.Down; break; default: return; } if (!currentMap.Exits.Any(e => e == exit)) { await Game.Network.SendMessageToPlayerAsync(player, "Invalid exit"); return; } request.Handled = true; var nextLocation = GetNextLocation(currentGridLocation, exit); var nextMap = Game.World.Maps.FirstOrDefault(map => map.Location.X == nextLocation.X && map.Location.Y == nextLocation.Y && map.Location.Z == nextLocation.Z); if (nextMap == null) { Game.Log(LogLevel.Information, $"next map not found {nextLocation}"); return; } await Game.World.MovePlayerAsync(player, nextMap); await base.LoggedInProcessAsync(request, player); }
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); }
private Task ProcessEditAsync(IProcessorData <CommandModel> request, IPlayer player) { request.Handled = true; Parser.Default.ParseArguments <EditMapParserOptions>(request.Data.StringFrom(2).Split(' ')) .WithParsed(async(parsed) => { var mapId = parsed.Id.HasValue ? parsed.Id.Value : player.Map.Id; var map = Game.World.Maps.FirstOrDefault(m => m.Id == mapId); var hasUpdate = false; if (parsed.Name.Any()) { var completeName = string.Join(" ", parsed.Name); if (!string.IsNullOrWhiteSpace(completeName)) { map.Name = completeName; hasUpdate = true; } } if (parsed.Description.Any()) { var complete = string.Join(" ", parsed.Description); if (!string.IsNullOrWhiteSpace(complete)) { map.Description = complete; hasUpdate = true; } } parsed.AddExits.ToList().ForEach((exit) => { try { map.AddExit(Enum.Parse <Exits>(exit, ignoreCase: true)); } catch (Exception) { Game.Log(Microsoft.Extensions.Logging.LogLevel.Information, "invalid exit.."); } hasUpdate = true; }); parsed.RemoveExits.ToList().ForEach((exit) => { map.RemoveExit(Enum.Parse <Exits>(exit, ignoreCase: true)); hasUpdate = true; }); if (hasUpdate) { await Game.Store.UpdateMapsAsync(Game, new List <IMap>() { map }); var mapView = MudLikeOperationBuilder.Start("mapdata").AddMap(map).Build(); await Game.Network.SendViewCommandsToMapAsync(map, MudLikeViewBuilder.Start().AddOperation(mapView).Build()); } }) .WithNotParsed(async(issues) => { await Game.Network.SendMessageToPlayerAsync(player, "invalid command(edit) - for help type map help"); }); return(Task.CompletedTask); }
private Task ProcessCreateAsync(IProcessorData <CommandModel> request, IPlayer player) { request.Handled = true; Parser.Default.ParseArguments <CreateMapParserOptions>(request.Data.StringFrom(2).Split(' ')) .WithParsed(async(parsed) => { if (string.IsNullOrEmpty(parsed.Direction) && parsed.X == null) { await Game.Network.SendMessageToPlayerAsync(player, "direction or location parameters are required"); return; } GridLocation newMapLocation = null; Exits parsedExit = Exits.None; var gridMap = (GridMap)player.Map; if (!string.IsNullOrEmpty(parsed.Direction)) { var parsedDirection = parsed.Direction; switch (parsedDirection) { case "n": case "north": parsedExit = Exits.North; break; case "e": case "east": parsedExit = Exits.East; break; case "s": case "south": parsedExit = Exits.South; break; case "w": case "west": parsedExit = Exits.West; break; case "u": case "up": parsedExit = Exits.Up; break; case "d": case "down": parsedExit = Exits.Down; break; } if (parsedExit == Exits.None) { await Game.Network.SendMessageToPlayerAsync(player, "direction was not valid"); return; } newMapLocation = GetNextLocation(gridMap.Location, parsedExit); } else { newMapLocation = new GridLocation(parsed.X.Value, parsed.Y.Value, parsed.Z.Value); } if (Game.World.Maps.Any(m => m.Location.X == newMapLocation.X && m.Location.Y == newMapLocation.Y && m.Location.Z == newMapLocation.Z)) { await Game.Network.SendMessageToPlayerAsync(player, "a map already exists at that location"); return; } var newMapExits = new List <Exits>(); // to help assist with creation, we are going to automatically add an exit on the current map for the direction of the next map. // this only occurs if the direction flag was used if (parsedExit != Exits.None) { if (!gridMap.Exits.Contains(parsedExit)) { Game.Log(Microsoft.Extensions.Logging.LogLevel.Information, "Adding exit to current map"); gridMap.AddExit(parsedExit); await Game.Store.UpdateMapsAsync(Game, new List <IMap>() { gridMap }); //var mapView = MudLikeCommandBuilder.Start() // .AddMap((GridMap)player.Map) // .AddPlayers(player.Map.Players) // .Build(ViewCommandType.Set); //await Game.Network.SendViewCommandsToMapAsync(gridMap, mapView); } // automatically add an exit back on the new map switch (parsedExit) { case Exits.North: newMapExits.Add(Exits.South); break; case Exits.East: newMapExits.Add(Exits.West); break; case Exits.South: newMapExits.Add(Exits.North); break; case Exits.West: newMapExits.Add(Exits.East); break; case Exits.Up: newMapExits.Add(Exits.Down); break; case Exits.Down: newMapExits.Add(Exits.Up); break; } } Game.Log(Microsoft.Extensions.Logging.LogLevel.Information, "saving new map"); var map = new GridMap(0, string.Join(" ", parsed.Name), string.Join(" ", parsed.Description), newMapLocation, newMapExits); map = (GridMap)await Game.Store.NewMapAsync(Game, (IMap)map); Game.Log(Microsoft.Extensions.Logging.LogLevel.Information, "adding to active world"); await Game.World.AddMapAsync(map); }) .WithNotParsed(async(issues) => { await Game.Network.SendMessageToPlayerAsync(player, "invalid command - for help type map help"); }); return(Task.CompletedTask); }
private Task ProcessSayAsync(IProcessorData <CommandModel> request, IPlayer player) { request.Handled = true; return(Game.Network.SendMessageToMapAsync(player.Map, $"{player.Name} says {request.Data.StringFrom(1)}")); }
public ReportInMock(IProcessorData processorData) : base(processorData) { }