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)
{
}
