/// <summary>Executes the command.</summary>
/// <param name="actionInput">The full input specified for executing the command.</param>
public override void Execute(ActionInput actionInput)
{
var session = actionInput.Session;
if (session == null)
{
return; // This action only makes sense for player sessions.
}
var output = new OutputBuilder();
foreach (var kvp in actionInput.Actor.Stats)
{
output.Append(kvp.Value.Name.PadRight(20));
output.Append(kvp.Value.Value);
output.AppendLine();
}
foreach (var kvp in actionInput.Actor.Attributes)
{
output.Append(kvp.Value.Name.PadRight(20));
output.Append(kvp.Value.Value);
output.AppendLine();
}
session.Write(output);
}
/// <summary>Shows who is currently following the player, and who the player is following.</summary>
/// <remarks>TODO: Replace the sender.Write() calls with something more general, e.g. an event.</remarks>
/// <param name="actionInput">The action input.</param>
private void ShowStatus(ActionInput actionInput)
{
var senderBehaviors = actionInput.Controller.Thing.Behaviors;
var followingBehavior = senderBehaviors.FindFirst <FollowingBehavior>();
var followedBehavior = senderBehaviors.FindFirst <FollowedBehavior>();
var output = new OutputBuilder();
output.Append("You are following: ");
output.AppendLine(followingBehavior == null ? "(nobody)" : followingBehavior.Target.Name);
output.Append("You are being followed by: ");
if (followedBehavior == null)
{
output.AppendLine("(nobody)");
}
else
{
lock (followedBehavior.Followers)
{
var followers = followedBehavior.Followers.Select(f => f.Name).BuildPrettyList();
output.AppendLine(followers);
}
}
actionInput.Controller.Write(output);
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var output = new OutputBuilder("Inventory: ");
var entities = commandEventArgs.Entity.GetInventoryItems();
if (entities.Count == 0)
{
output.Append("You aren't carrying anything.");
}
else
{
var itemDescriptions = EntityQuantityMapper.ParseEntityQuantitiesAsStrings(entities, EntityQuantityMapper.MapStringTypes.ShortDescription);
output.Append(Formatter.NewTableFromList(itemDescriptions, 1, 4, 0));
}
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
// TODO: Update once command dictionary is created to iterate Keys and output valid commands.
// TODO: Create help file for each command.
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var output = new OutputBuilder();
output.Append("Valid commands are:");
output.Append(
Formatter.NewTableFromList(
CommandService.AvailableCommands(
commandEventArgs.PrivilegeOverride == null
? commandEventArgs.Entity.PrivilegeLevel
: (PrivilegeLevel)commandEventArgs.PrivilegeOverride),
6, 5, Formatter.DefaultIndent));
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var room = commandEventArgs.Entity.GetInstanceParentRoom();
if (room == null)
{
return(CommandResult.Failure("You must be in a shop first."));
}
if (!room.IsShop)
{
return(CommandResult.Failure("There is no shop available here."));
}
var output = new OutputBuilder();
var nameToSell = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
if (nameToSell == "")
{
return(CommandResult.InvalidSyntax(nameof(Sell), new List <string> {
"item name"
}));
}
// Search inventory for a match
var inventoryEntities = commandEventArgs.Entity.GetInventoryItems();
if (inventoryEntities.Count == 0)
{
return(new CommandResult(ResultCode.FAIL, "You don't have anything to sell!"));
}
var itemMatched = Parse.MatchOnEntityNameByOrder(nameToSell, inventoryEntities.Cast <IEntity>().ToList());
if (itemMatched == null)
{
return(CommandResult.Failure("You can't seem to find it."));
}
var item = (EntityInanimate)itemMatched;
output.Append($"You sell {item.ShortDescription} for {item.Value}!");
// Remove item and give currency
commandEventArgs.Entity.RemoveInventoryItem(item.Instance);
commandEventArgs.Entity.Currency += item.Value;
DataAccess.Remove <EntityInanimate>(item.Instance, CacheType.Instance);
return(CommandResult.Success(output.Output));
}
/// <summary>
/// Lists known skills
/// </summary>
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
EntityAnimate entity = commandEventArgs.Entity;
List <ISkill> skills = new List <ISkill>();
foreach (var s in entity.Skills)
{
skills.Add(s);
}
OutputBuilder result = new OutputBuilder();
foreach (var s in skills)
{
result.Append($"{SkillMap.SkillToFriendlyName(s.GetType())} [{(int)s.SkillLevel}]\n");
}
return(CommandResult.Success(result.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var room = commandEventArgs.Entity.GetInstanceParentRoom();
if (room == null)
{
return(CommandResult.Failure("You must be in a shop first."));
}
if (!room.IsShop)
{
return(CommandResult.Failure("There is no shop available here."));
}
var output = new OutputBuilder();
var items = room.ShopItems.GetAllEntitiesAsObjects <EntityInanimate>();
if (items.Count == 0)
{
output.Append("Everything has been purchased!");
}
else
{
output.Append("Available for purchase: ");
// var itemDescriptions = EntityQuantityMapper.ParseEntityQuantitiesAsStrings(items, EntityQuantityMapper.MapStringTypes.ShortDescription);
var itemDescriptions = new List <string>();
foreach (var i in items)
{
itemDescriptions.Add(i.Value.ToString());
itemDescriptions.Add(i.ShortDescription);
}
output.Append(Formatter.NewTableFromList(itemDescriptions, 2, 4, 4));
}
return(CommandResult.Success(output.Output));
}
/// <summary>Executes the command.</summary>
/// <param name="actionInput">The full input specified for executing the command.</param>
public override void Execute(ActionInput actionInput)
{
var output = new OutputBuilder();
foreach (var kvp in actionInput.Controller.Thing.Stats)
{
output.Append(kvp.Value.Name.PadRight(20));
output.Append(kvp.Value.Value);
output.AppendLine();
}
foreach (var kvp in actionInput.Controller.Thing.Attributes)
{
output.Append(kvp.Value.Name.PadRight(20));
output.Append(kvp.Value.Value);
output.AppendLine();
}
actionInput.Controller.Write(output);
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var output = new OutputBuilder();
Player player = (Player)commandEventArgs.Entity;
string arg = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
switch (arg)
{
case "ON":
player.Configuration.Autodig = true;
output.Append("You will now automatically dig when moving.");
break;
case "OFF":
player.Configuration.Autodig = false;
output.Append("You will no longer automatically dig when moving.");
break;
case "":
string configState = player.Configuration.Autodig == true ? "on" : "off";
output.Append($"Autodig is set to {configState}.");
break;
default:
return(CommandResult.InvalidSyntax(nameof(Autodig), new List <string> {
"on", "off"
}));
}
return(CommandResult.Success(output.Output));
}
/// <summary>Executes the command.</summary>
/// <param name="actionInput">The full input specified for executing the command.</param>
public override void Execute(ActionInput actionInput)
{
var session = actionInput.Session;
if (session == null)
{
return; // This action only makes sense for player sessions.
}
var output = new OutputBuilder();
//// TODO Reference to config file
var appName = "WheelMUD.vshost.exe";
output.AppendSeparator('=', "red", true);
output.AppendLine("System Status:");
output.AppendSeparator('-', "red");
////ManagementObjectCollection queryCollection1 = query1.Get();
var query1 = new ManagementObjectSearcher("SELECT * FROM Win32_ComputerSystem");
var queryCollection1 = query1.Get();
foreach (ManagementObject mo in queryCollection1)
{
output.Append($"Manufacturer : {mo["manufacturer"]}");
output.AppendLine($"Model : {mo["model"]}");
output.AppendLine($"Physical Ram : {(ulong)mo["totalphysicalmemory"] / 1024}");
}
output.AppendSeparator('-', "red");
query1 = new ManagementObjectSearcher("SELECT * FROM Win32_process where NAME = '" + appName + "'");
queryCollection1 = query1.Get();
foreach (ManagementObject mo in queryCollection1)
{
foreach (var item in mo.Properties)
{
output.AppendLine($"<%b%><%red%>{item.Name}<%b%><%yellow%>{item.Value}<%n%>");
}
}
output.AppendSeparator('-', "red");
query1 = new ManagementObjectSearcher("SELECT * FROM Win32_timezone");
queryCollection1 = query1.Get();
foreach (ManagementObject mo in queryCollection1)
{
output.AppendLine($"This Server lives in:{mo["caption"]}");
}
session.Write(output);
}
private async Task <IResult> _ExpectAsync(IMatch matcher, Action <IResult> handler, int timeout = 0, bool timeout_throws = false)
{
CancellationTokenSource tokenSource = new CancellationTokenSource();
IResult result = matcher;
Task timeoutTask = null;
if (timeout == 0)
{
timeout = this.Timeout;
}
if (timeout > 0)
{
timeoutTask = Task.Delay(timeout);
}
StringBuilder matchOutputBuilder = new StringBuilder(1000);
Task <string> readTask = _spawnable.ReadAsync();
IList <Task> tasks = new List <Task>();
tasks.Add(readTask);
if (timeoutTask != null)
{
tasks.Add(timeoutTask);
}
Task completed = await Task.WhenAny(tasks).ConfigureAwait(false);
if (completed == readTask)
{
string output = readTask.Result;
OutputBuilder.Append(output);
matchOutputBuilder.Append(output);
matcher.Execute(matchOutputBuilder.ToString());
if (result.IsMatch)
{
handler?.Invoke(result);
}
}
else
{
if (timeout_throws)
{
throw new TimeoutException(string.Format("Timed out waiting for match for {0} in output {1}.", matcher.Query, matchOutputBuilder.ToString()));
}
;
}
tokenSource.Dispose();
return(result);
}
/// <summary>
/// Handles NameSelection state
/// </summary>
/// <returns>The result of the handled input</returns>
private CommandResult HandleNameSelection(string input, EntityAnimate entity)
{
if (InputValidation.ValidPlayerName(input))
{
entity.Name = input;
var output = new OutputBuilder($"Welcome to HedronMUD, {entity.Name}!");
return(CommandResult.Success(output.Output));
}
else
{
var output = new OutputBuilder("Please enter a valid player name containing only letters and between 3-12 characters.");
output.Append("\nPlease enter your player name: ");
return(CommandResult.InvalidSyntax(output.Output));
}
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var player = (Player)commandEventArgs.Entity;
var output = new OutputBuilder();
player.ShortDescription = commandEventArgs.Argument;
output.Append($"Your short description has been set to:\n {commandEventArgs.Argument}");
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var name = commandEventArgs.Argument;
var room = commandEventArgs.Entity.GetInstanceParentRoom();
// Argument checking to ensure a name was provided
if (name == null || name == "")
{
return(CommandResult.InvalidSyntax($"{nameof(Mgenerate)}", "Please enter the base name of the mob you wish to create.", new List <string>()
{
"name"
}));
}
// Ensure the player is in a room so the mobs can be created here
if (room == null)
{
return(CommandResult.Failure("You must be in a room to execute this command."));
}
// Create new mobs of all levels and instantiate them in this room
var mobs = AutogenMob.CreateAndInstantiateAllLevels(name, room.Instance);
var output = new OutputBuilder();
foreach (var mob in mobs)
{
output.Append($"You have created {DataAccess.Get<Mob>(mob, CacheType.Instance).ShortDescription}");
}
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var nameToDrink = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
if (nameToDrink == "")
{
return(CommandResult.InvalidSyntax(nameof(Drink), new List <string> {
"potion name"
}));
}
// Search inventory for a match
var inventoryEntities = commandEventArgs.Entity.GetInventoryItems().Where(i => i.GetType() == typeof(ItemPotion)).ToList();
if (inventoryEntities.Count == 0)
{
return(new CommandResult(ResultCode.FAIL, "You don't have anything to drink!"));
}
var output = new OutputBuilder();
var itemMatched = Parse.MatchOnEntityNameByOrder(nameToDrink, inventoryEntities.Cast <IEntity>().ToList());
if (itemMatched == null)
{
return(CommandResult.Failure("You can't seem to find it."));
}
var potion = (ItemPotion)itemMatched;
output.Append($"You drink {potion.ShortDescription}");
if (potion.Effect != null)
{
commandEventArgs.Entity.AddEffect(potion.Effect, false);
output.Append(potion.Effect.ApplyDescriptionSelf);
}
if (potion.PoolRestoration != null)
{
int energyChange = 0;
int healthChange = 0;
int staminaChange = 0;
if (potion.PoolRestoration.IsMultiplier)
{
energyChange = (int)(commandEventArgs.Entity.ModifiedPools.Energy.GetValueOrDefault() * potion.PoolRestoration.Energy.GetValueOrDefault());
healthChange = (int)(commandEventArgs.Entity.ModifiedPools.HitPoints.GetValueOrDefault() * potion.PoolRestoration.HitPoints.GetValueOrDefault());
staminaChange = (int)(commandEventArgs.Entity.ModifiedPools.Stamina.GetValueOrDefault() * potion.PoolRestoration.Stamina.GetValueOrDefault());
}
else
{
energyChange = (int)(potion.PoolRestoration.Energy.GetValueOrDefault());
healthChange = (int)(potion.PoolRestoration.HitPoints.GetValueOrDefault());
staminaChange = (int)(potion.PoolRestoration.Stamina.GetValueOrDefault());
}
if (energyChange != 0)
{
commandEventArgs.Entity.ModifyCurrentEnergy(energyChange, false);
output.Append(string.Format("You feel your energy {0}.", energyChange > 0 ? "recharge" : "drain"));
}
if (healthChange != 0)
{
commandEventArgs.Entity.ModifyCurrentHealth(healthChange, false);
output.Append(string.Format("You feel your health {0}.", healthChange > 0 ? "improve" : "fade"));
}
if (staminaChange != 0)
{
commandEventArgs.Entity.ModifyCurrentStamina(staminaChange, false);
output.Append(string.Format("You feel your stamina {0}.", staminaChange > 0 ? "refresh" : "falter"));
}
}
// Remove potion from instance and prototype inventory/caches (automatically updates persistence accordingly)
commandEventArgs.Entity.RemoveInventoryItem(potion.Instance);
var protoEntity = DataAccess.Get <EntityAnimate>(commandEventArgs.Entity.Prototype, CacheType.Prototype);
protoEntity?.RemoveInventoryItem(potion.Prototype);
DataAccess.Remove <ItemPotion>(potion.Prototype, CacheType.Prototype);
// TODO: Add entity persistence once player saving works
// DataPersistence.SaveObject(protoEntity);
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var nameToWear = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
var entity = commandEventArgs.Entity;
if (nameToWear == "")
{
return(new CommandResult(ResultCode.ERR_SYNTAX, "What would you like to wear?"));
}
// Search inventory for a match
var inventoryEntities = entity.GetInventoryItems();
if (inventoryEntities.Count == 0)
{
if (nameToWear == "ALL")
{
return(CommandResult.Failure("You don't have anything to wear."));
}
else
{
return(new CommandResult(ResultCode.ERR_SYNTAX, "You don't have that."));
}
}
var output = new OutputBuilder();
List <EntityInanimate> itemsMarkedAsWorn = new List <EntityInanimate>();
if (nameToWear == "ALL")
{
// A list of items that will be removed from inventory after they have been worn
List <EntityInanimate> itemsToRemoveFromInventory = new List <EntityInanimate>();
// Find each item in the inventory that can be worn, and if there is still room in the corresponding slot,
// equip it.
foreach (var item in inventoryEntities)
{
try
{
entity.EquipItemAt(item.Instance, item.Slot, false);
entity.RemoveInventoryItem(item.Instance);
itemsMarkedAsWorn.Add(item);
}
catch (SlotFullException)
{
continue;
}
}
}
else
{
// Find the given item in inventory and equip it, removing any currently equipped items as necessary
List <EntityInanimate> itemsRemoved = new List <EntityInanimate>();
var itemMatched = Parse.MatchOnEntityNameByOrder(nameToWear, inventoryEntities.Cast <IEntity>().ToList());
if (itemMatched != null)
{
try
{
// Equip the item and swap already equipped items to inventory
itemsRemoved = entity.EquipItemAt(itemMatched.Instance, ((EntityInanimate)itemMatched).Slot, true);
entity.RemoveInventoryItem(itemMatched.Instance);
itemsMarkedAsWorn.Add((EntityInanimate)itemMatched);
foreach (var item in itemsRemoved)
{
output.Append($"You remove {item.ShortDescription} and put it in your pack.");
}
}
catch (InvalidSlotException)
{
// Only equip wearable items
return(CommandResult.Failure("You can't equip that."));
}
}
else
{
// The item requested to be removed was not found
return(CommandResult.Failure("You don't have that."));
}
}
// Reorder list
itemsMarkedAsWorn = itemsMarkedAsWorn.OrderBy(i => i.Name).ThenBy(i => i.ShortDescription).ToList();
// Parse output based on items worn
if (itemsMarkedAsWorn.Count == 0)
{
output.Append("There is nothing more for you to wear.");
}
else
{
foreach (var item in itemsMarkedAsWorn)
{
switch (item.Slot)
{
case ItemSlot.Light:
output.Append($"You equip {item.ShortDescription} as your lightsource.");
break;
case ItemSlot.Orbit:
output.Append($"You release {item.ShortDescription} in your orbit.");
break;
case ItemSlot.OneHandedWeapon:
output.Append($"You equip {item.ShortDescription} as your weapon.");
break;
case ItemSlot.TwoHandedWeapon:
output.Append($"You equip {item.ShortDescription} as your weapon.");
break;
case ItemSlot.Shield:
output.Append($"You equip {item.ShortDescription} as your shield.");
break;
default:
output.Append($"You wear {item.ShortDescription} upon your {item.Slot.ToString().ToLower()}.");
break;
}
}
}
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var entity = commandEventArgs.Entity;
var basePools = entity.BaseMaxPools;
var baseAttributes = entity.BaseAttributes;
var baseQualities = entity.BaseQualities;
var modPools = entity.ModifiedPools;
var modAttributes = entity.ModifiedAttributes;
var modQualities = entity.ModifiedQualities;
var poolsTable = Formatter.ToTable(2, Formatter.DefaultIndent,
// HP row
Formatter.NewRow(
"Hit Points: ",
$"{entity.CurrentHitPoints}",
"/",
$"{basePools.HitPoints}",
""
),
// Stamina row
Formatter.NewRow(
"Stamina: ",
$"{entity.CurrentStamina}",
"/",
$"{basePools.Stamina}",
""
),
// Energy row
Formatter.NewRow(
"Energy: ",
$"{entity.CurrentEnergy}",
"/",
$"{basePools.Energy}",
""
)
);
var attributesTable = Formatter.ToTable(2, Formatter.DefaultIndent,
// Essence row
Formatter.NewRow(
"Essence: ",
$"{baseAttributes.Essence}",
$"[{modAttributes.Essence}]"
),
// Finesse row
Formatter.NewRow(
"Finesse: ",
$"{baseAttributes.Finesse}",
$"[{modAttributes.Finesse}]"
),
// Intellect row
Formatter.NewRow(
"Intellect: ",
$"{baseAttributes.Intellect}",
$"[{modAttributes.Intellect}]"
),
// Might row
Formatter.NewRow(
"Might: ",
$"{baseAttributes.Might}",
$"[{modAttributes.Might}]"
),
// Spirit row
Formatter.NewRow(
"Spirit: ",
$"{baseAttributes.Spirit}",
$"[{modAttributes.Spirit}]"
),
// Will row
Formatter.NewRow(
"Will: ",
$"{baseAttributes.Will}",
$"[{modAttributes.Will}]"
)
);
var qualitiesTable = Formatter.ToTable(2, Formatter.DefaultIndent,
// Attack and Armor row
Formatter.NewRow(
"Attack Rating: ",
$"{baseQualities.AttackRating}",
$"[{modQualities.AttackRating}]",
"Armor Rating: ",
$"{baseQualities.ArmorRating}",
$"[{modQualities.ArmorRating}]"
),
// Critical Hit and Damage row
Formatter.NewRow(
"Critical Hit: ",
$"{baseQualities.CriticalHit}",
$"[{modQualities.CriticalHit}]",
"Critical Damage: ",
$"{baseQualities.CriticalDamage}",
$"[{modQualities.CriticalDamage}]"
)
);
var output = new OutputBuilder(
"Statistics:\n" +
poolsTable + "\n\n" +
attributesTable + "\n\n" +
qualitiesTable + "\n\n"
);
if (entity.Currency.HasAnyValue())
{
output.Append("[Currency] " + entity.Currency.ToString() + "\n\n");
}
else
{
output.Append("[Currency] none\n\n");
}
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var nameToDrop = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
if (nameToDrop == "")
{
return(new CommandResult(ResultCode.ERR_SYNTAX, "What would you like to drop?"));
}
var room = commandEventArgs.Entity.GetInstanceParentRoom();
if (room == null)
{
return(CommandResult.Failure("There is nowhere to drop it to."));
}
// Search inventory for a match
var inventoryEntities = commandEventArgs.Entity.GetInventoryItems();
if (inventoryEntities.Count == 0)
{
if (nameToDrop == "ALL")
{
return(CommandResult.Failure("You don't have anything to drop."));
}
else
{
return(new CommandResult(ResultCode.ERR_SYNTAX, "You don't have that."));
}
}
List <EntityInanimate> matchedItems;
var output = new OutputBuilder();
if (nameToDrop == "ALL")
{
matchedItems = inventoryEntities;
}
else
{
matchedItems = new List <EntityInanimate>();
var itemMatched = Parse.MatchOnEntityNameByOrder(nameToDrop, inventoryEntities.Cast <IEntity>().ToList());
if (itemMatched != null)
{
matchedItems.Add((EntityInanimate)itemMatched);
}
}
if (matchedItems.Count == 0)
{
return(CommandResult.Failure("You don't have that."));
}
foreach (var item in matchedItems)
{
commandEventArgs.Entity.RemoveInventoryItem(item.Instance);
room.Items.AddEntity(item.Instance, item, false);
}
if (matchedItems.Count == 1)
{
output.Append("You drop " + matchedItems[0].ShortDescription + ".");
}
else
{
var droppedItems = EntityQuantityMapper.ParseEntityQuantitiesAsStrings(matchedItems, EntityQuantityMapper.MapStringTypes.ShortDescription);
output.Append("You drop:");
output.Append(Formatter.NewTableFromList(droppedItems, 1, 4, 0));
}
return(CommandResult.Success(output.Output));
}
public void WriteLabel(string name)
{
OutputBuilder.Append($"{name} ");
}
public CommandResult Execute(CommandEventArgs commandEventArgs, Constants.EXIT direction)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var output = new OutputBuilder();
var entity = commandEventArgs.Entity;
Room sourceRoom = entity.GetInstanceParentRoom();
// Don't move entity if it's not already in a room
if (sourceRoom != null && entity != null)
{
RoomExits exits = sourceRoom.Exits;
Room destRoom;
switch (direction)
{
case Constants.EXIT.NORTH:
destRoom = DataAccess.Get <Room>(exits.North, CacheType.Instance);
break;
case Constants.EXIT.EAST:
destRoom = DataAccess.Get <Room>(exits.East, CacheType.Instance);
break;
case Constants.EXIT.SOUTH:
destRoom = DataAccess.Get <Room>(exits.South, CacheType.Instance);
break;
case Constants.EXIT.WEST:
destRoom = DataAccess.Get <Room>(exits.West, CacheType.Instance);
break;
case Constants.EXIT.UP:
destRoom = DataAccess.Get <Room>(exits.Up, CacheType.Instance);
break;
case Constants.EXIT.DOWN:
destRoom = DataAccess.Get <Room>(exits.Down, CacheType.Instance);
break;
default:
output.Append("You cannot go that way.");
return(CommandResult.Failure(output.Output));
}
if (destRoom != null)
{
sourceRoom.Animates.RemoveEntity(entity.Instance, entity);
destRoom.Animates.AddEntity(entity.Instance, entity, false);
output.Append(
new Look()
.Execute(new CommandEventArgs("", commandEventArgs.Entity, commandEventArgs.PrivilegeOverride))
.ResultMessage);
return(CommandResult.Success(output.Output));
}
else
{
// Create the room if Autodig is set
if (entity.GetType() == typeof(Player))
{
var player = (Player)entity;
if (player.Configuration.Autodig)
{
sourceRoom = DataAccess.Get <Room>(sourceRoom.Prototype, CacheType.Prototype);
if (sourceRoom == null)
{
return(CommandResult.Failure("You must be in a room with a saved prototype before you may dig."));
}
var sourceArea = entity.GetInstanceParentArea();
if (sourceArea == null)
{
return(CommandResult.Failure("You must be in an area before you may dig."));
}
var protoArea = DataAccess.Get <Area>(sourceArea.Prototype, CacheType.Prototype);
if (protoArea == null)
{
return(CommandResult.Failure("You must be in an area with a saved prototype before you may dig."));
}
destRoom = Room.NewPrototype((uint)protoArea.Prototype);
destRoom.Spawn(false, (uint)sourceArea.Instance);
RoomExits.ConnectRoomExits(sourceRoom, destRoom, direction, true, true);
// Now move the entity to the new room
output.Append($"You dig {direction.ToString().ToLower()}.");
output.Append(new MoveEntity().Execute(commandEventArgs).ResultMessage);
return(CommandResult.Success(output.Output));
}
}
output.Append("You cannot go that way.");
return(CommandResult.Failure(output.Output));
}
}
// Return failure if entity was not already in a room or there was no entity to move
output.Append("You cannot go that way.");
return(CommandResult.Failure(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var nameToRemove = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
if (nameToRemove == "")
{
return(new CommandResult(ResultCode.ERR_SYNTAX, "What would you like to remove?"));
}
// Search equipment for a match
var equipmentEntities = commandEventArgs.Entity.GetEquippedItems();
if (equipmentEntities.Count == 0)
{
if (nameToRemove == "ALL")
{
return(CommandResult.Failure("You aren't wearing anything."));
}
else
{
return(new CommandResult(ResultCode.ERR_SYNTAX, "You don't have that equipped."));
}
}
List <EntityInanimate> matchedItems;
if (nameToRemove == "ALL")
{
matchedItems = equipmentEntities;
}
else
{
matchedItems = new List <EntityInanimate>();
var itemMatched = Parse.MatchOnEntityNameByOrder(nameToRemove, equipmentEntities.Cast <IEntity>().ToList());
if (itemMatched != null)
{
matchedItems.Add((EntityInanimate)itemMatched);
}
}
if (matchedItems.Count == 0)
{
return(new CommandResult(ResultCode.ERR_SYNTAX, "You don't have that equipped."));
}
var output = new OutputBuilder();
foreach (var item in matchedItems)
{
commandEventArgs.Entity.UnequipItem(item.Instance);
output.Append($"You remove {item.ShortDescription} and place it in your pack.");
}
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
string arg = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
string opt = CommandService.ParseFirstArgument(CommandService.ParseArgument(commandEventArgs.Argument)).ToUpper();
OutputBuilder output = new OutputBuilder();
var entity = commandEventArgs.Entity;
switch (arg)
{
case "POTION":
ItemPotion newPotion;
if (opt == "ENERGY")
{
newPotion = ItemPotion.NewInstance(true);
newPotion.PoolRestoration = new Pools
{
Energy = 50
};
newPotion.Name = "energy potion";
newPotion.ShortDescription = "an energy potion";
newPotion.LongDescription = "A lovely blue energy potion.";
}
else if (opt == "HEALTH")
{
newPotion = ItemPotion.NewInstance(true);
newPotion.PoolRestoration = new Pools
{
HitPoints = 50
};
newPotion.Name = "health potion";
newPotion.ShortDescription = "a health potion";
newPotion.LongDescription = "A lovely red health potion.";
}
else if (opt == "STAMINA")
{
newPotion = ItemPotion.NewInstance(true);
newPotion.PoolRestoration = new Pools
{
Stamina = 50
};
newPotion.Name = "stamina potion";
newPotion.ShortDescription = "a stamina potion";
newPotion.LongDescription = "A lovely green stamina potion.";
}
else
{
return(CommandResult.InvalidSyntax("craft potion", new List <string> {
"energy", "health", "stamina"
}));
}
output.Append($"You craft {newPotion.ShortDescription}.");
// Add potion to inventory, save potion
entity.AddInventoryItem(newPotion.Instance);
var protoPotion = DataAccess.Get <ItemPotion>(newPotion.Prototype, CacheType.Prototype);
newPotion.CopyTo(protoPotion);
// TODO: Update data persistence once player saving works
// var entityProto = DataAccess.Get<EntityAnimate>(entity.Prototype, CacheType.Prototype);
// entityProto?.AddInventoryItem(newPotion.Prototype);
// DataPersistence.SaveObject(entityProto);
DataPersistence.SaveObject(DataAccess.Get <ItemPotion>(newPotion.Prototype, CacheType.Prototype));
break;
default:
return(CommandResult.InvalidSyntax("craft", new List <string> {
"potion"
}));
}
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
// TODO: Implement Look <Direction>
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var output = new OutputBuilder();
var entity = commandEventArgs.Entity;
var argument = commandEventArgs.Argument;
var room = entity.GetInstanceParentRoom();
if (room != null)
{
var items = room.Items.GetAllEntitiesAsObjects <EntityInanimate>();
var storage = room.StorageItems.GetAllEntitiesAsObjects <Storage>();
var mobs = room.Animates.GetAllEntitiesAsObjects <Mob>();
var players = room.Animates.GetAllEntitiesAsObjects <Player>();
if (entity.GetType() == typeof(Player))
{
players.Remove((Player)entity);
}
else if (entity.GetType() == typeof(Mob))
{
mobs.Remove((Mob)entity);
}
if (argument?.Length > 0)
{
var allEntities = new List <IEntity>();
allEntities.AddRange(items);
allEntities.AddRange(storage);
allEntities.AddRange(mobs);
allEntities.AddRange(players);
var matchedEntity = Parse.MatchOnEntityNameByOrder(argument, allEntities);
if (matchedEntity != null)
{
output.Append(matchedEntity.LongDescription);
}
else
{
return(CommandResult.Failure("You do not see that here."));
}
}
else
{
var area = entity.GetInstanceParentArea();
output.Append("");
if (entity.GetType() == typeof(Player))
{
output.Append(((Player)entity).Configuration.DisplayAreaName
? $"{area.Name} > {room.Name}"
: room.Name);
}
output.Append(room.Description);
output.Append("Exits: " + Formatter.ParseExits(room));
// Print players
if (players.Count > 0)
{
foreach (var desc in EntityQuantityMapper.ParseEntityQuantitiesAsStrings(players, EntityQuantityMapper.MapStringTypes.ShortDescription))
{
output.Append(desc);
}
}
// Print mobs
if (mobs.Count > 0)
{
output.Append(string.Join(", ",
EntityQuantityMapper.ParseEntityQuantitiesAsStrings(mobs, EntityQuantityMapper.MapStringTypes.ShortDescription).ToArray()));
}
// Print items
if (items.Count > 0)
{
output.Append(string.Join(", ",
EntityQuantityMapper.ParseEntityQuantitiesAsStrings(items, EntityQuantityMapper.MapStringTypes.ShortDescription).ToArray()));
}
// Print containers
if (storage.Count > 0)
{
output.Append(string.Join(", ",
EntityQuantityMapper.ParseEntityQuantitiesAsStrings(storage, EntityQuantityMapper.MapStringTypes.ShortDescription).ToArray()));
}
}
}
else
{
output.Append("You are in the void...");
}
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var nameToGet = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
if (nameToGet == "")
{
return(new CommandResult(ResultCode.ERR_SYNTAX, "What would you like to get?"));
}
// Search room for a match
var room = commandEventArgs.Entity.GetInstanceParentRoom();
var roomEntities = room.Items.GetAllEntitiesAsObjects <EntityInanimate>();
if (roomEntities.Count == 0)
{
// There are no items in the room to pick up
if (nameToGet == "ALL")
{
return(new CommandResult(ResultCode.SUCCESS, "There is nothing to pick up."));
}
else
{
return(new CommandResult(ResultCode.FAIL, "You don't see that."));
}
}
List <EntityInanimate> matchedItems;
var output = new OutputBuilder();
if (nameToGet == "ALL")
{
matchedItems = roomEntities;
}
else
{
matchedItems = new List <EntityInanimate>();
var itemMatched = Parse.MatchOnEntityNameByOrder(nameToGet, roomEntities.Cast <IEntity>().ToList());
if (itemMatched != null)
{
matchedItems.Add((EntityInanimate)itemMatched);
}
}
if (matchedItems.Count == 0)
{
return(new CommandResult(ResultCode.FAIL, "You don't see that."));
}
foreach (var item in matchedItems)
{
room.Items.RemoveEntity(item.Instance, item);
commandEventArgs.Entity.AddInventoryItem(item.Instance);
}
if (matchedItems.Count == 1)
{
output.Append("You pick up " + matchedItems[0].ShortDescription + ".");
}
else
{
var itemsPicked = EntityQuantityMapper.ParseEntityQuantitiesAsStrings(matchedItems, EntityQuantityMapper.MapStringTypes.ShortDescription);
output.Append("You pick up:");
output.Append(Formatter.NewTableFromList(itemsPicked, 1, 4, 0));
}
return(CommandResult.Success(output.Output));
}
/// <summary>
/// Sets player configurations
/// </summary>
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var output = new OutputBuilder();
Player player = (Player)commandEventArgs.Entity;
string arg = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
string opt = CommandService.ParseFirstArgument(CommandService.ParseArgument(commandEventArgs.Argument)).ToUpper();
switch (arg)
{
case "AREANAME":
if (opt == "ON")
{
player.Configuration.DisplayAreaName = true;
output.Append("You will now see area names.");
}
else if (opt == "OFF")
{
player.Configuration.DisplayAreaName = false;
output.Append("You will no longer see area names.");
}
else
{
return(CommandResult.InvalidSyntax("config areaname", new List <string> {
"on", "off"
}));
}
break;
case "COLOR":
if (opt == "ON")
{
player.Configuration.UseColor = true;
output.Append("Color is now enabled.");
}
else if (opt == "OFF")
{
player.Configuration.UseColor = false;
output.Append("Color is now disabled.");
}
else
{
return(CommandResult.InvalidSyntax("config color", new List <string> {
"on", "off"
}));
}
break;
default:
return(CommandResult.InvalidSyntax(nameof(Config), new List <string> {
"areaname", "color"
}, new List <string> {
"option"
}));
}
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var room = commandEventArgs.Entity.GetInstanceParentRoom();
if (room == null)
{
return(CommandResult.Failure("You must be in a shop first."));
}
if (!room.IsShop)
{
return(CommandResult.Failure("There is no shop available here."));
}
var output = new OutputBuilder();
var items = room.ShopItems.GetAllEntitiesAsObjects <EntityInanimate>();
if (items.Count == 0)
{
output.Append("There is nothing left to buy!");
}
else
{
var nameToBuy = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
if (nameToBuy == "")
{
return(CommandResult.InvalidSyntax(nameof(Sell), new List <string> {
"item name"
}));
}
var itemMatched = Parse.MatchOnEntityNameByOrder(nameToBuy, items.Cast <IEntity>().ToList());
if (itemMatched == null)
{
return(CommandResult.Failure("That's not for sale here."));
}
var item = (EntityInanimate)itemMatched;
if (commandEventArgs.Entity.Currency.TotalCopper < item.Value.TotalCopper ||
commandEventArgs.Entity.Currency.Vita < item.Value.Vita ||
commandEventArgs.Entity.Currency.Menta < item.Value.Menta ||
commandEventArgs.Entity.Currency.Astra < item.Value.Astra)
{
return(CommandResult.Failure($"You don't have enough to pay for that! ({item.Value})"));
}
output.Append($"You buy {item.ShortDescription} for {item.Value}!");
// Move item and subtract currency
room.ShopItems.RemoveEntity(item.Instance, item);
commandEventArgs.Entity.AddInventoryItem(item.Instance);
commandEventArgs.Entity.Currency -= item.Value;
}
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var output = new OutputBuilder("Equipment: ");
var wornItems = commandEventArgs.Entity.GetEquippedItems()
.OrderBy(item => item.Name)
.ToList();
if (wornItems.Count == 0)
{
output.Append("You aren't wearing anything.");
}
else
{
// Initialize item slot column
var slots = new List <string>();
foreach (var slot in Enum.GetValues(typeof(ItemSlot)))
{
slots.Add(slot.ToString());
}
// Determine width of item slot column
int maxSlotTextWidth = 0;
foreach (var slot in slots)
{
if (slot.Length > maxSlotTextWidth)
{
maxSlotTextWidth = slot.Length;
}
}
// Pad item slot column
maxSlotTextWidth += 3;
// Initialize equipment list table
var mappedEquipment = new Dictionary <ItemSlot, List <string> >();
foreach (var slot in Enum.GetValues(typeof(ItemSlot)))
{
mappedEquipment.Add((ItemSlot)slot, new List <string>());
}
// Build out descriptions for worn equipment
foreach (var slot in mappedEquipment)
{
foreach (var item in wornItems)
{
if (item.Slot == slot.Key)
{
mappedEquipment[slot.Key].Add(item.ShortDescription);
}
}
}
// Print a formatted table of worn equipment
foreach (var slot in mappedEquipment)
{
foreach (var item in slot.Value)
{
output.Append(
string.Format("{0," + maxSlotTextWidth + "}: {1}", slot.Key.ToString(), item));
}
}
}
return(CommandResult.Success(output.Output));
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var output = new OutputBuilder();
var argument = commandEventArgs.Argument;
var entity = commandEventArgs.Entity;
if (!string.IsNullOrEmpty(argument) && entity != null)
{
int iRoom = -1;
try
{
// Try to convert argument to guid
iRoom = Convert.ToInt32(CommandService.ParseFirstArgument(argument));
}
catch (FormatException)
{
return(CommandResult.InvalidSyntax(nameof(Goto), new List <string> {
"list", "[room number]"
}));
}
catch (OverflowException)
{
Logger.Error(nameof(CommandService), nameof(Goto), "Overflow exception.");
}
var targetRoom = DataAccess.Get <Room>((uint)iRoom, CacheType.Instance);
if (targetRoom != null)
{
// Move entity
var sourceRoom = entity.GetInstanceParentRoom();
sourceRoom?.Animates.RemoveEntity(entity.Instance, entity);
targetRoom.Animates.AddEntity(entity.Instance, entity, false);
output.Append(
new Look()
.Execute(new CommandEventArgs("", commandEventArgs.Entity, commandEventArgs.PrivilegeOverride))
.ResultMessage);
return(CommandResult.Success(output.Output));
}
else
{
output.Append("Invalid room.");
return(CommandResult.Failure(output.Output));
}
}
else
{
if (!string.IsNullOrEmpty(argument) && argument.ToLower() == "list")
{
var rooms = DataAccess.GetAll <Room>(CacheType.Instance);
foreach (var r in rooms)
{
output.Append($"({r.Instance}): {r.GetInstanceParentArea().Name}/{r.Name}");
}
return(CommandResult.Success(output.Output));
}
else
{
return(CommandResult.InvalidSyntax(nameof(Goto), new List <string> {
"list", "[room number]"
}));
}
}
}
public virtual void WriteLiteral(object value)
{
OutputBuilder.Append(value);
}
public override CommandResult Execute(CommandEventArgs commandEventArgs)
{
try
{
base.Execute(commandEventArgs);
}
catch (CommandException ex)
{
return(ex.CommandResult);
}
var player = (Player)commandEventArgs.Entity;
var output = new OutputBuilder();
var argument = CommandService.ParseFirstArgument(commandEventArgs.Argument).ToUpper();
switch (argument)
{
case "CLEAR":
player.Prompt = "";
output.Append("Your prompt has been cleared.");
break;
case "RESET":
if (player.Configuration.UseColor)
{
player.Prompt = Constants.Prompt.DEFAULT_COLOR;
}
else
{
player.Prompt = Constants.Prompt.DEFAULT;
}
output.Append($"Your prompt has been set to:\n {player.Prompt}");
break;
case "SET":
var arg = CommandService.ParseArgument(commandEventArgs.Argument);
if (arg == "")
{
var help = Formatter.NewTableFromList(
new List <string>
{
"Valid placeholders are:",
"Valid color codes are:",
"$hp - Current hit points",
$"`{Formatter.FriendlyColorBlack} - Black",
"$HP - Maximum hit points",
$"`{Formatter.FriendlyColorBlue} - Blue",
"$st - Current stamina",
$"`{Formatter.FriendlyColorBold} - (Bold)",
"$ST - Maximum stamina",
$"`{Formatter.FriendlyColorCyan} - Cyan",
"$en - Current energy",
$"`{Formatter.FriendlyColorGreen} - Green",
"$EN - Maximum energy",
$"`{Formatter.FriendlyColorMagenta} - Magenta",
"",
$"`{Formatter.FriendlyColorRed} - Red",
"",
$"`{Formatter.FriendlyColorReset} - (Reset)",
"",
$"`{Formatter.FriendlyColorWhite} - White",
"",
$"`{Formatter.FriendlyColorYellow} - Yellow"
}, 2, 4, 4);
if (!player.Prompt.EndsWith(Formatter.FriendlyColorReset))
{
player.Prompt += Formatter.FriendlyColorReset;
}
return(CommandResult.InvalidSyntax(nameof(Prompt), $"\n{help}", new List <string> {
"set [new prompt]"
}));
}
player.Prompt = arg;
output.Append($"Your prompt has been set to:\n {arg}");
break;
default:
return(CommandResult.InvalidSyntax(nameof(Prompt), new List <string> {
"clear", "reset", "set"
}));
}
return(CommandResult.Success(output.Output));
}
