protected virtual bool DoLock(string rawParameters, params CommandParameter[] parameters)
{
if (parameters.Length == 0)
{
Send("Lock what?");
return(true);
}
// TODO: search item
// No item found, search door
ExitDirections exitDirection;
IExit exit = VerboseFindDoor(parameters[0], out exitDirection);
if (exit == null)
{
return(true);
}
if (!exit.IsClosed)
{
Send("It's not closed.");
return(true);
}
if (exit.Blueprint.Key <= 0)
{
Send("It can't be locked.");
return(true);
}
// search key
bool keyFound = Content.OfType <IItemKey>().Any(x => x.Blueprint.Id == exit.Blueprint.Key);
if (!keyFound)
{
Send("You lack the key.");
return(true);
}
if (exit.IsLocked)
{
Send("It's already locked.");
return(true);
}
// Unlock this side
exit.Lock();
Send("*Click*");
Act(ActOptions.ToRoom, "{0:N} locks the {1}.", this, exit);
// Unlock other side
IExit otherSideExit = exit.Destination.Exit(ExitHelpers.ReverseDirection(exitDirection));
if (otherSideExit != null)
{
otherSideExit.Lock();
}
else
{
Log.Default.WriteLine(LogLevels.Warning, $"Non bidirectional exit in room {Room.Blueprint.Id} direction {exitDirection}");
}
return(true);
}
// Helpers
private IExit VerboseFindDoor(CommandParameter parameter, out ExitDirections exitDirection)
{
bool wasAskingForDirection;
bool found = FindDoor(parameter, out exitDirection, out wasAskingForDirection);
if (!found)
{
// if open north -> I see no door north here.
// if open black door -> I see no black door here.
if (wasAskingForDirection)
{
Send($"I see no door {parameter.Value} here.");
}
else
{
Send($"I see no {parameter.Value} here.");
}
return(null);
}
IExit exit = Room.Exit(exitDirection);
if (exit == null)
{
return(null);
}
if (!exit.IsDoor)
{
Send("You can't do that.");
return(null);
}
return(exit);
}
private static IExit FindExit(Direction direction, IRoom room)
{
IExit exit = null;
switch (direction)
{
case Direction.North:
exit = room.North;
break;
case Direction.East:
exit = room.East;
break;
case Direction.South:
exit = room.South;
break;
case Direction.West:
exit = room.West;
break;
case Direction.Up:
exit = room.Up;
break;
case Direction.Down:
exit = room.Down;
break;
}
return(exit);
}
public Engine(ISetupPark setupPark, IPark park, IExit exit, IFindVehicle findVehicle, IVehiclesByOwner vehiclesByOwner, IStatus status)
{
this.setupPark = setupPark;
this.park = park;
this.exit = exit;
this.findVehicle = findVehicle;
this.vehiclesByOwner = vehiclesByOwner;
this.status = status;
}
public TurtleMoveCommandTests()
{
ITurtleMoveService turtleMoveService = Mock.Of <TurtleMoveService>();
_board = Mock.Of <Board>();
_mine = Mock.Of <Mine>();
_exit = Mock.Of <Exit>();
_turtle = new Turtle(turtleMoveService);
}
public Room(Guid guid, RoomBlueprint blueprint, IArea area)
: base(guid, blueprint.Name, blueprint.Description)
{
Blueprint = blueprint;
_people = new List <ICharacter>();
_content = new List <IItem>();
Exits = new IExit[ExitHelpers.ExitCount];
Area = area;
Area.AddRoom(this);
}
private IDoor GetDoor(IExit exit, string keyword)
{
if (exit.Door != null)
{
if (exit.Door.KeyWords.Any(s => s.Equals(keyword, StringComparison.OrdinalIgnoreCase)))
{
return(exit.Door);
}
}
return(null);
}
private void AddDoors(IExit exit, string keyword, List <IDoor> doors)
{
if (exit != null)
{
IDoor door = GetDoor(exit, keyword);
if (door != null)
{
doors.Add(door);
}
}
}
public TurtleGameInvoker(IBoard board,
IExit exit,
ITurtle turtle,
IInitializationService <ITurtle, IMine> initializationService)
{
_board = board;
_mines = new List <IMine>();
_exit = exit;
_turtle = turtle;
_initializationService = initializationService;
}
public IResult PerformCommand(IMobileObject performer, ICommand command)
{
IResult result = base.PerfomCommand(performer, command);
if (result != null)
{
return(result);
}
//check to see if they are mounted on their mount
if (performer.Mount != null &&
performer.Mount.Room == performer.Room &&
performer.Mount.Riders.Contains(performer))
{
//they are mounted, send the move to command to their mount
performer.Mount.EnqueueCommand(command.CommandName);
return(null);
}
result = GlobalReference.GlobalValues.CanMobDoSomething.Move(performer);
if (result != null)
{
return(result);
}
IRoom room = performer.Room;
Direction direction = FindDirection(command);
IExit exit = FindExit(direction, room);
result = ValidateExit(exit);
if (result != null)
{
return(result);
}
result = room.CheckLeave(performer);
if (result != null)
{
return(result);
}
result = room.CheckLeaveDirection(performer, direction);
if (result != null)
{
return(result);
}
IRoom proposedRoom = GlobalReference.GlobalValues.World.Zones[exit.Zone].Rooms[exit.Room];
//we are safe to cross zones because we make a copy of each pc/npc list before processing it in a thread safe manor
return(MoveToRoom(performer, room, direction, proposedRoom));
}
private IResult ValidateExit(IExit exit)
{
if (exit == null)
{
return(new Result(false, "There is no obvious way to leave that way."));
}
if (exit.Door != null && exit.Door.Opened == false)
{
string message = string.Format("You will need to open the {0} first.", exit.Door.SentenceDescription);
return(new Result(false, message));
}
return(null);
}
public TurtleGameInvokerTests()
{
IAnimalValidator animalValidator = Mock.Of <AnimalValidator>();
IBoardValidator boardValidator = Mock.Of <BoardValidator>();
IExitValidator exitValidator = Mock.Of <ExitValidator>();
IObstaclesValidator obstaclesValidator = Mock.Of <ObstaclesValidator>();
_commandParserService = new CommandParserService(animalValidator, boardValidator, exitValidator, obstaclesValidator);
IInitializationService <ITurtle, IMine> initializationService = new TurtleInitializationService();
ITurtleMoveService turtleMoveService = Mock.Of <TurtleMoveService>();
IBoard board = Mock.Of <Board>();
IExit exit = Mock.Of <Exit>();
ITurtle turtle = new Turtle(turtleMoveService);
_invoker = new TurtleGameInvoker(board, exit, turtle, initializationService);
}
protected virtual bool DoOpen(string rawParameters, params CommandParameter[] parameters)
{
if (parameters.Length == 0)
{
Send("Open what?");
return(true);
}
// TODO: search item
// No item found, search door
ExitDirections exitDirection;
IExit exit = VerboseFindDoor(parameters[0], out exitDirection);
if (exit == null)
{
return(true);
}
if (!exit.IsClosed)
{
Send("It's already open.");
return(true);
}
if (exit.IsLocked)
{
Send("It's locked.");
return(true);
}
// Open this side side
exit.Open();
Act(ActOptions.ToRoom, "{0:N} opens the {1}.", this, exit);
Send("Ok.");
// Open the other side
IExit otherSideExit = exit.Destination.Exit(ExitHelpers.ReverseDirection(exitDirection));
if (otherSideExit != null)
{
otherSideExit.Open();
Act(exit.Destination.People, "The {0} opens.", otherSideExit);
}
else
{
Log.Default.WriteLine(LogLevels.Warning, $"Non bidirectional exit in room {Room.Blueprint.Id} direction {exitDirection}");
}
return(true);
}
private bool FindDoor(CommandParameter parameter, out ExitDirections exitDirection, out bool wasAskingForDirection)
{
if (ExitHelpers.FindDirection(parameter.Value, out exitDirection))
{
wasAskingForDirection = true;
return(true);
}
wasAskingForDirection = false;
//exit = Room.Exits.FirstOrDefault(x => x?.Destination != null && x.IsDoor && x.Keywords.Any(k => FindHelpers.StringStartsWith(k, parameter.Value)));
foreach (ExitDirections direction in EnumHelpers.GetValues <ExitDirections>())
{
IExit exit = Room.Exit(direction);
if (exit?.Destination != null && exit.IsDoor && exit.Keywords.Any(k => FindHelpers.StringStartsWith(k, parameter.Value)))
{
exitDirection = direction;
return(true);
}
}
return(false);
}
public IResult PerformCommand(IMobileObject performer, ICommand command)
{
IResult result = GlobalReference.GlobalValues.CanMobDoSomething.Move(performer);
if (result != null)
{
return(result);
}
IRoom room = performer.Room;
Direction direction = FindDirection(command);
IExit exit = FindExit(direction, room);
result = ValidateExit(exit);
if (result != null)
{
return(result);
}
result = room.CheckLeave(performer);
if (result != null)
{
return(result);
}
result = room.CheckLeaveDirection(performer, direction);
if (result != null)
{
return(result);
}
IRoom proposedRoom = GlobalReference.GlobalValues.World.Zones[exit.Zone].Rooms[exit.Room];
return(MoveToRoom(performer, room, direction, proposedRoom));
}
private string GetExitDescription(IExit exit, IRoom room) {
//there's a lot of sentence
string[] vowel = new string[] { "a", "e", "i", "o", "u" };
RoomExits direction = (RoomExits)Enum.Parse(typeof(RoomExits), exit.Direction.CamelCaseWord());
if (room.IsDark) {
exit.Description = "something";
}
if (string.IsNullOrEmpty(exit.Description)) {
exit.Description = exit.availableExits[direction].Title.ToLower();
}
if (exit.Description.Contains("that leads to")) {
exit.Description += exit.availableExits[direction].Title.ToLower();
}
string directionCorrected = "To the " + exit.Direction + " there is ";
if (String.Compare(exit.Direction, "up", true) == 0 || String.Compare(exit.Direction, "down", true) == 0) {
if (!room.IsDark) {
directionCorrected = exit.Description;
}
else {
directionCorrected = "something";
}
directionCorrected += " leads " + exit.Direction + " towards ";
if (!room.IsDark) {
exit.Description = "somewhere";
}
else {
exit.Description = exit.availableExits[direction].Title.ToLower();
}
}
if (!exit.Description.Contains("somewhere") && vowel.Contains(exit.Description[0].ToString())) {
directionCorrected += "an ";
}
else if (!exit.Description.Contains("somewhere") && exit.Description != "something") {
directionCorrected += "a ";
}
return (directionCorrected + exit.Description + ".");
}
private void AddRoom(IZone zone, IRoom room, int x, int y, int z)
{
roomStack.Push(new RoomPositionInfo(room, x, y, z));
while (roomStack.Count != 0)
{
RoomPositionInfo roomPositionInfo = roomStack.Pop();
room = roomPositionInfo.Room;
x = roomPositionInfo.X;
y = roomPositionInfo.Y;
z = roomPositionInfo.Z;
if (Grid.ContainsKey(room))
{
//return;
}
else
{
MapRoom mapRoom = new MapRoom(zone, room, new Position(x, y, z));
Grid.Add(room, mapRoom);
hashPositions.Add(mapRoom.Position.ToString());
}
if (room.North != null)
{
IExit exit = room.North;
if (exit.Zone == room.Zone)
{
IRoom newRoom = zone.Rooms[exit.Room];
if (!Grid.ContainsKey(newRoom))
{
Position currentPosition = Grid[room].Position;
while (CheckPosition(currentPosition.X, currentPosition.Y + 1, currentPosition.Z))
{
MigrateSouth(currentPosition.Y);
}
roomStack.Push(new RoomPositionInfo(newRoom, currentPosition.X, currentPosition.Y + 1, currentPosition.Z));
}
}
}
if (room.East != null)
{
IExit exit = room.East;
if (exit.Zone == room.Zone)
{
IRoom newRoom = zone.Rooms[exit.Room];
if (!Grid.ContainsKey(newRoom))
{
Position currentPosition = Grid[room].Position;
while (CheckPosition(currentPosition.X + 1, currentPosition.Y, currentPosition.Z))
{
MigrateWest(currentPosition.X);
}
roomStack.Push(new RoomPositionInfo(newRoom, currentPosition.X + 1, currentPosition.Y, currentPosition.Z));
}
}
}
if (room.South != null)
{
IExit exit = room.South;
if (exit.Zone == room.Zone)
{
IRoom newRoom = zone.Rooms[exit.Room];
if (!Grid.ContainsKey(newRoom))
{
Position currentPosition = Grid[room].Position;
while (CheckPosition(currentPosition.X, currentPosition.Y - 1, currentPosition.Z))
{
MigrateNorth(currentPosition.Y);
}
roomStack.Push(new RoomPositionInfo(newRoom, currentPosition.X, currentPosition.Y - 1, currentPosition.Z));
}
}
}
if (room.West != null)
{
IExit exit = room.West;
if (exit.Zone == room.Zone)
{
IRoom newRoom = zone.Rooms[exit.Room];
if (!Grid.ContainsKey(newRoom))
{
Position currentPosition = Grid[room].Position;
while (CheckPosition(currentPosition.X - 1, currentPosition.Y, currentPosition.Z))
{
MigrateEast(currentPosition.X);
}
roomStack.Push(new RoomPositionInfo(newRoom, currentPosition.X - 1, currentPosition.Y, currentPosition.Z));
}
}
}
if (room.Up != null)
{
IExit exit = room.Up;
if (exit.Zone == room.Zone)
{
IRoom newRoom = zone.Rooms[exit.Room];
if (!Grid.ContainsKey(newRoom))
{
Position currentPosition = Grid[room].Position;
while (CheckPosition(currentPosition.X, currentPosition.Y, currentPosition.Z + 1))
{
MigrateDown(currentPosition.Z);
}
roomStack.Push(new RoomPositionInfo(newRoom, currentPosition.X, currentPosition.Y, currentPosition.Z + 1));
}
}
}
if (room.Down != null)
{
IExit exit = room.Down;
if (exit.Zone == room.Zone)
{
IRoom newRoom = zone.Rooms[exit.Room];
if (!Grid.ContainsKey(newRoom))
{
Position currentPosition = Grid[room].Position;
while (CheckPosition(currentPosition.X, currentPosition.Y, currentPosition.Z - 1))
{
MigrateUp(currentPosition.Z);
}
roomStack.Push(new RoomPositionInfo(newRoom, currentPosition.X, currentPosition.Y, currentPosition.Z - 1));
}
}
}
}
}
protected virtual bool DoRstat(string rawParameters, params CommandParameter[] parameters)
{
if (parameters.Length == 0 && Impersonating == null)
{
Send("Rstat what?");
return(true);
}
if (parameters.Length >= 1 && !parameters[0].IsNumber)
{
Send("Syntax: rstat [<room id>]");
return(true);
}
IRoom room;
if (Impersonating != null)
{
room = Impersonating.Room;
}
else
{
int id = parameters[0].AsNumber;
room = DependencyContainer.Instance.GetInstance <IWorld>().Rooms.FirstOrDefault(x => x.Blueprint.Id == id);
}
if (room == null)
{
Send("It doesn't exist.");
return(true);
}
StringBuilder sb = new StringBuilder();
if (room.Blueprint != null)
{
sb.AppendFormatLine("Blueprint: {0}", room.Blueprint.Id);
}
else
{
sb.AppendLine("No blueprint");
}
sb.AppendFormatLine("Name: {0}", room.Blueprint?.Name ?? "(none)");
sb.AppendFormatLine("DisplayName: {0}", room.DisplayName);
sb.AppendFormatLine("Description: {0}", room.Description);
if (room.ExtraDescriptions != null)
{
foreach (KeyValuePair <string, string> kv in room.ExtraDescriptions)
{
sb.AppendFormatLine("ExtraDescription: {0} " + Environment.NewLine + "{1}", kv.Key, kv.Value);
}
}
foreach (ExitDirections direction in EnumHelpers.GetValues <ExitDirections>())
{
IExit exit = room.Exit(direction);
if (exit?.Destination != null)
{
sb.Append(StringHelpers.UpperFirstLetter(direction.ToString()));
sb.Append(" - ");
sb.Append(exit.Destination.DisplayName); // TODO: too dark to tell
if (exit.IsClosed)
{
sb.Append(" (CLOSED)");
}
if (exit.IsHidden)
{
sb.Append(" [HIDDEN]");
}
if (exit.IsLocked)
{
sb.AppendFormat(" <Locked> {0}", exit.Blueprint.Key);
}
sb.Append($" [{exit.Destination.Blueprint?.Id.ToString() ?? "???"}]");
sb.AppendLine();
}
// TODO: exits
// TODO: content
// TODO: people
}
Send(sb);
return(true);
}
/// <summary>
/// Move
/// </summary>
/// <param name="movements">Movement</param>
/// <param name="mines">Collection of mine</param>
/// <param name="exit">Exit</param>
public void Move(IEnumerable <Movement> movements, IEnumerable <IMine> mines, IExit exit)
{
var isHitMine = false;
var isExit = false;
foreach (var movement in movements)
{
if (movement == Movement.Move)
{
// Make sure the turtle still in the board.
if (!Board.IsValid(Point))
{
throw new PointValidationException("Turtle cannot go out of board!");
}
// Move the turtle to the next tile.
_turtleMoveService.MoveForward(Point);
// If the turtle hits the mine it will not continue.
if (_turtleMoveService.IsObstacleHit(Point, mines))
{
Result = $"Mine Hit";
isHitMine = true;
break;
}
// If the turtle finds the exit it will not continue.
if (_turtleMoveService.IsExit(Point, exit))
{
Result = $"Success";
isExit = true;
break;
}
}
else if (movement == Movement.Left)
{
// Turn left the turtle.
_turtleMoveService.MoveLeft(Point);
}
else if (movement == Movement.Right)
{
// Turn right the turtle.
_turtleMoveService.MoveRight(Point);
}
}
if (!isHitMine && !isExit)
{
Result = "Still In Danger";
}
}
private void DisplayExits(bool compact)
{
StringBuilder message = new StringBuilder();
if (compact)
{
message.Append("[Exits:");
}
else
{
message.AppendLine("Obvious exits:");
}
bool exitFound = false;
foreach (ExitDirections direction in EnumHelpers.GetValues <ExitDirections>())
{
IExit exit = Room.Exit(direction);
if (exit?.Destination != null && CanSee(exit))
{
if (compact)
{
message.Append(" ");
if (exit.IsHidden)
{
message.Append("[");
}
if (exit.IsClosed)
{
message.Append("(");
}
message.AppendFormat("{0}", direction.ToString().ToLowerInvariant());
if (exit.IsClosed)
{
message.Append(")");
}
if (exit.IsHidden)
{
message.Append("]");
}
}
else
{
message.Append(StringHelpers.UpperFirstLetter(direction.ToString()));
message.Append(" - ");
if (exit.IsClosed)
{
message.Append("A closed door");
}
else
{
message.Append(exit.Destination.DisplayName); // TODO: too dark to tell
}
if (exit.IsClosed)
{
message.Append(" (CLOSED)");
}
if (exit.IsHidden)
{
message.Append(" [HIDDEN]");
}
if (ImpersonatedBy is IAdmin)
{
message.Append($" [{exit.Destination.Blueprint?.Id.ToString() ?? "???"}]");
}
message.AppendLine();
}
exitFound = true;
}
}
if (!exitFound)
{
if (compact)
{
message.AppendLine(" none");
}
else
{
message.AppendLine("None.");
}
}
if (compact)
{
message.AppendLine("]");
}
Send(message);
}
public CreateTemplateViewModel(ITemplateCreater templateCreater, IExit exit)
{
_templateCreater = templateCreater;
_exit = exit;
}
/// <summary>
/// Set
/// </summary>
/// <param name="turtle">Turtle</param>
/// <param name="mines">Mines collections</param>
/// <param name="exit">Exit</param>
public void Set(ITurtle turtle, IEnumerable <IMine> mines, IExit exit)
{
_turtle = turtle;
_mines = mines;
_exit = exit;
}
private Trail AddNextRoom(HashSet <IRoom> searchedRooms, Directions.Direction direction, IExit exit, IMobileObject performer, Queue <Trail> newTrails, Trail trail)
{
if (trail.Distance > 3) //don't follow someone that has gotten to far away to follow
{
return(null);
}
if (exit != null)
{
IRoom nextRoom = Zones[exit.Zone].Rooms[exit.Room];
if (searchedRooms.Contains(nextRoom))
{
return(null);
}
trail.Distance++;
IMobileObject foundMob = FindMobInRoom(nextRoom, performer);
if (foundMob != null)
{
return(trail);
}
if (!searchedRooms.Contains(nextRoom))
{
trail.Room = nextRoom;
newTrails.Enqueue(trail);
searchedRooms.Add(nextRoom);
}
}
return(null);
}
/// <summary>
/// Set
/// </summary>
/// <param name="board">Board</param>
/// <param name="exit">Exit</param>
public void Set(IBoard board, IExit exit)
{
_board = board;
_exit = exit;
}
public void AddExit(IExit exit)
{
ExitObjects.Add(exit);
}
private Trail AddNextRoom(IMobileObject performer, HashSet <IRoom> searchedRooms, Directions.Direction direction, IExit exit, string targetKeyword, Queue <Trail> newTrails, Trail trail)
{
if (exit != null)
{
IRoom nextRoom = GlobalReference.GlobalValues.World.Zones[exit.Zone].Rooms[exit.Room];
if (searchedRooms.Contains(nextRoom))
{
return(null);
}
//check to make sure the next room does not contain the attribute NoTrack
//if so return null
if (nextRoom.Attributes.Contains(RoomAttribute.NoTrack))
{
searchedRooms.Add(nextRoom); //don't bother to keep searching this room
return(null);
}
trail.Distance++;
IMobileObject foundMob = FindMobInRoom(nextRoom, targetKeyword);
if (foundMob != null)
{
return(trail);
}
if (!searchedRooms.Contains(nextRoom))
{
trail.Room = nextRoom;
newTrails.Enqueue(trail);
searchedRooms.Add(nextRoom);
}
}
return(null);
}
/// <summary>
/// Is exit
/// </summary>
/// <param name="point">Point</param>
/// <param name="exit">Exit</param>
/// <returns></returns>
public bool IsExit(IPoint point, IExit exit)
{
return(exit.Point.X == point.X && exit.Point.Y == point.Y);
}
protected virtual bool DoLook(string rawParameters, params CommandParameter[] parameters)
{
// TODO: 0/ sleeping/blind/dark room (see act_info.C:1413 -> 1436)
// 1: room+exits+chars+items
if (string.IsNullOrWhiteSpace(rawParameters))
{
Log.Default.WriteLine(LogLevels.Debug, "DoLook(1): room");
DisplayRoom();
return(true);
}
// 2: container in room then inventory then equipment
if (parameters[0].Value == "in" || parameters[0].Value == "on" || parameters[0].Value == "into")
{
Log.Default.WriteLine(LogLevels.Debug, "DoLook(2): container in room, inventory, equipment");
// look in container
if (parameters.Length == 1)
{
Send("Look in what?");
}
else
{
// search in room, then in inventory(unequiped), then in equipement
IItem containerItem = FindHelpers.FindItemHere(this, parameters[1]);
if (containerItem == null)
{
Send(StringHelpers.ItemNotFound);
}
else
{
Log.Default.WriteLine(LogLevels.Debug, "DoLook(2): found in {0}", containerItem.ContainedInto.DebugName);
IContainer container = containerItem as IContainer;
if (container != null)
{
DisplayContainerContent(container);
}
// TODO: drink container
else
{
Send("This is not a container.");
}
}
}
return(true);
}
// 3: character in room
ICharacter victim = FindHelpers.FindByName(Room.People.Where(CanSee), parameters[0]);
if (victim != null)
{
Log.Default.WriteLine(LogLevels.Debug, "DoLook(3): character in room");
DisplayCharacter(victim, true); // TODO: always peeking ???
return(true);
}
// 4:search among inventory/equipment/room.content if an item has extra description or name equals to parameters
string itemDescription;
bool itemFound = FindItemByExtraDescriptionOrName(parameters[0], out itemDescription);
if (itemFound)
{
Log.Default.WriteLine(LogLevels.Debug, "DoLook(4): item in inventory+equipment+room -> {0}", itemDescription);
Send(itemDescription, false);
return(true);
}
// 5: extra description in room
if (Room.ExtraDescriptions != null && Room.ExtraDescriptions.Any())
{
// TODO: try to use ElementAtOrDefault
int count = 0;
foreach (KeyValuePair <string, string> extraDescription in Room.ExtraDescriptions)
{
if (parameters[0].Tokens.All(x => FindHelpers.StringStartsWith(extraDescription.Key, x)) &&
++count == parameters[0].Count)
{
Send(extraDescription.Value, false);
return(true);
}
}
}
// 6: direction
ExitDirections direction;
if (ExitHelpers.FindDirection(parameters[0].Value, out direction))
{
Log.Default.WriteLine(LogLevels.Debug, "DoLook(6): direction");
IExit exit = Room.Exit(direction);
if (exit?.Destination == null)
{
Send("Nothing special there.");
}
else
{
Send(exit.Description ?? "Nothing special there.");
if (exit.Keywords.Any())
{
if (exit.IsClosed)
{
Act(ActOptions.ToCharacter, "The {0} is closed.", exit);
}
else if (exit.IsDoor)
{
Act(ActOptions.ToCharacter, "The {0} is open.", exit);
}
}
}
}
else
{
Send(StringHelpers.ItemNotFound);
}
return(true);
}
/// <summary>
/// Initialization Exit Set Command
/// </summary>
/// <param name="board">Board</param>
/// <param name="exit">Exit</param>
/// <param name="command">Command</param>
public void InitializationExitSetCommand(IBoard board, IExit exit, ICommand command)
{
var exitSetCommand = (IExitSetCommand)command;
exitSetCommand.Set(board, exit);
}
public ExitSetCommandTests()
{
_board = Mock.Of <Board>();
_exit = Mock.Of <Exit>();
}
/// <summary>
/// Initializatiob animal move command
/// </summary>
/// <param name="turtle">Animal</param>
/// <param name="mines">Obstacles</param>
/// <param name="exit">Exit</param>
/// <param name="command">Command</param>
public void InitializationAnimalMoveCommand(ITurtle turtle, IEnumerable <IMine> mines, IExit exit, ICommand command)
{
var turtleMoveCommand = (ITurtleMoveCommand)command;
turtleMoveCommand.Set(turtle, mines, exit);
}
