public InventoryCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
: base(console, factory, queries, formatters)
{
AddCommandName("inventory");
AddCommandName("inv");
AddCommandName("i");
}
public TakeCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
: base(console, factory, queries, formatters)
{
AddCommandName("take");
AddCommandName("pickup");
AddCommandName("get");
}
public DropCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
: base(console, factory, queries, formatters)
{
AddCommandName("drop");
AddCommandName("putdown");
AddCommandName("release");
}
public EmoteCommand(IConsoleWrapper console)
{
dict = new Dictionary<string, string>();
AddCommand("LOL", "You laugh out loud!");
AddCommand("fence", "You fence with {1}!");
this.console = console;
}
public WordSearchProgramHelperIntegrationTests()
{
_testUtilities = new TestUtilities();
_originalConsoleOutput = Console.Out;
_consoleOuput = new StringWriter();
_fileOperations = new FileOperations();
_wordFinder = new WordFinder();
_searchOrientationManager = new SearchOrientationManager();
_consoleWrapper = new ConsoleWrapper();
Console.SetOut(_consoleOuput);
}
public void StartBattleship()
{
var player1 = "Player 1";
var player2 = "Player 2";
_coordinatesReader = new CoordinatesReader();
_console = new ConsoleWrapper();
var player1Board = InitialiseBoard(player1, 3);
var player2Board = InitialiseBoard(player2, 3);
Run(player1Board, player2Board);
}
public void GetParameter_ValidValueInserted_ReturnTheNumber(string valueInserted, decimal numberInserted)
{
IConsoleWrapper stubConsole = Substitute.For <IConsoleWrapper>();
stubConsole.ReadLine().Returns(valueInserted);
ConsoleManager sut = new ConsoleManager(stubConsole);
decimal firstArgument;
bool isValid = sut.GetParameter(out firstArgument, "Insert first number");
Assert.True(isValid);
Assert.AreEqual(numberInserted, firstArgument);
}
public override Task Execute(DateTime signalTime, IConsoleWrapper console, CancellationToken token)
{
if (token.IsCancellationRequested)
{
_console.WriteLine($"Operation interrupted by token for: {GetType().Name}");
return(Task.CompletedTask);
}
base.Execute(signalTime, token);
_console.WriteLine($"Executed: {signalTime}");
return(Task.CompletedTask);
}
public void GetParameter_ValidValueInserted_NotWriteErrorLogToConsole(string valueInserted)
{
IConsoleWrapper mockConsole = Substitute.For <IConsoleWrapper>();
mockConsole.ReadLine().Returns(valueInserted);
ConsoleManager sut = new ConsoleManager(mockConsole);
decimal number;
sut.GetParameter(out number, ConsoleMessages.InsertFirstNumber);
mockConsole.DidNotReceive().WriteLine(ConsoleMessages.InvalidArgument, valueInserted);
}
public Calculator(bool inputFromConsole, IGetterOperation getterOperation, IConsoleWrapper consoleWrapper)
{
if (getterOperation == null)
{
throw new ArgumentNullException("getterOperation");
}
if (consoleWrapper == null)
{
throw new ArgumentNullException("consoleWrapper");
}
this.IsInputFromConsole = inputFromConsole;
this.GetterOperation = getterOperation;
this.ConsoleWrapper = consoleWrapper;
}
public Startup(
IServiceProvider serviceProvider,
IConsoleWrapper <Startup> consoleWrapper,
IAppletSettingsManager appletSettingsManager,
IValueGeneratorManager valueGeneratorManager,
ICommandParser commandParser)
{
this.serviceProvider = serviceProvider;
this.consoleWrapper = consoleWrapper;
appletSettingsChangedSubscriber = appletSettingsManager.AppletSettingsChanged(AppletSettingsChanged);
appletSettingsManager.UpdateValue(appletSetting => appletSetting.IsRunning, true);
this.commandParser = commandParser;
}
public void Init()
{
_weatherClient = Substitute.For <IWeatherClient>();
_cityDataAccess = Substitute.For <ICityDataAccess>();
_consoleWrapper = Substitute.For <IConsoleWrapper>();
_weatherClient.CitySearch(Arg.Any <string>()).Returns(new List <SearchCityDto>());
_weatherClient.GetWeather(Arg.Any <string>()).Returns(new CurrentWeatherDto());
_cityDataAccess.GetAllCities().Returns(new List <SearchCityDto>());
_consoleWrapper.WriteLine(Arg.Any <string>());
_consoleWrapper.ReadLine().Returns(string.Empty);
_sut = new FrontEndLogic(_weatherClient, _cityDataAccess, _consoleWrapper, 1);
}
public static void Run(IConsoleWrapper console)
{
var robot = new RobotFacade(new Robot());
var lifetime = console.ReadLine();
var startPos = console.ReadLine().Split(' ');
robot.Initialize(lifetime, startPos[0], startPos[1]);
while (!robot.IsDone())
{
var next = console.ReadLine().Split(' ');
robot.Move(next[0], next[1]);
}
console.WriteLine("=> Cleaned: " + robot.NumberOfUniqueVisitedFields);
}
public void GetPassword([ValueSource(nameof(PasswordProviderTestCases))] ConsolePasswordProviderTest test)
{
IConsoleWrapper consoleWrapper = Substitute.For <IConsoleWrapper>();
var chars = test.InputChars;
var iterator = 0;
consoleWrapper.ReadKey(true).Returns(s => { ConsoleKeyInfo key = chars[iterator];
++iterator;
return(key); });
var passwordProvider = new ConsolePasswordProvider(new ConsoleUtils(consoleWrapper));
var password = passwordProvider.GetPassword(Address.Zero);
Assert.IsTrue(password.IsReadOnly());
Assert.AreEqual(test.ExpectedPassword, password.Unsecure());
}
internal static void ColorFor(this IConsoleWrapper self, TestUnitResult result)
{
if (result.IsPending)
{
self.Yellow();
}
else if (result.Failed)
{
self.Red();
}
else if (result.Passed)
{
self.Green();
}
}
public void GetParameter_GetOperator_CheckIfValid(string valueInserted)
{
IConsoleWrapper stubConsole = Substitute.For <IConsoleWrapper>();
IValidator mockOperatorValidator = Substitute.For <IValidator>();
stubConsole.ReadLine().Returns(valueInserted);
mockOperatorValidator.IsValid(Arg.Any <string>()).Returns(true);
ConsoleManager sut = new ConsoleManager(stubConsole);
string operation;
sut.GetParameter(out operation, "Insert the Operation", mockOperatorValidator);
mockOperatorValidator.Received().IsValid(valueInserted);
}
public void GetParameter_ValidOperatorInserted_ReturnTheOperator(string valueInserted)
{
IConsoleWrapper stubConsole = Substitute.For <IConsoleWrapper>();
IValidator stubOperatorValidator = Substitute.For <IValidator>();
stubConsole.ReadLine().Returns(valueInserted);
stubOperatorValidator.IsValid(Arg.Any <string>()).Returns(true);
ConsoleManager sut = new ConsoleManager(stubConsole);
string operation;
bool isValid = sut.GetParameter(out operation, "Insert the Operation", stubOperatorValidator);
Assert.True(isValid);
Assert.AreEqual(valueInserted, operation);
}
public override Task Execute(DateTime signalTime, IConsoleWrapper console, CancellationToken token)
{
foreach (var item in _repository.GetProductsPurchasedForAllCustomers())
{
if (token.IsCancellationRequested)
{
_console.WriteLine($"Operation interrupted by token for: {GetType().Name}");
break;
}
_console.WriteLine($"Executed:{signalTime}.\t{item}");
Thread.Sleep(500);
}
return(Task.CompletedTask);
}
/// <summary>
/// The start game menu.
/// </summary>
/// <param name="output">
/// The output.
/// </param>
/// <param name="view">
/// The console view.
/// </param>
/// <param name="timer">
/// The console timer.
/// </param>
public static void StartGameMenu(
IConsoleWrapper<ConsoleColor, ConsoleKeyInfo> output,
IConsoleView view,
ConsoleTimer timer)
{
EventHandler ev1 =
(sender, args) =>
{
gameController =
new MinesweeperGameController(
MinesweeperGridFactory.CreateNewTable(MinesweeperDifficultyType.Easy),
view,
timer,
LoadPlayers(),
MinesweeperDifficultyType.Easy);
};
EventHandler ev2 =
(sender, args) =>
{
gameController =
new MinesweeperGameController(
MinesweeperGridFactory.CreateNewTable(MinesweeperDifficultyType.Medium),
view,
timer,
LoadPlayers(),
MinesweeperDifficultyType.Medium);
};
EventHandler ev3 =
(sender, args) =>
{
gameController =
new MinesweeperGameController(
MinesweeperGridFactory.CreateNewTable(MinesweeperDifficultyType.Hard),
view,
timer,
LoadPlayers(),
MinesweeperDifficultyType.Hard);
};
EventHandler ev4 = (sender, args) => { StartMainMenu(output); };
DisplayFourItemsMenu("Easy", "Medium", "Hard", "Back", ev1, ev2, ev3, ev4, output);
}
private void MakeATurn(Warrior player, IConsoleWrapper consoleWrapper)
{
(int x, int y)oldPosition;
int currentSpeedPoints;
int moves = 0;
bool isInputValid = true;
currentSpeedPoints = player.SpeedPoints;
while (moves < currentSpeedPoints && _game.Status == GameStatusType.Running)
{
oldPosition = (player.Position.X, player.Position.Y);
if (isInputValid)
{
Console.WriteLine($"Player{player.Symbol}, make a move please!");
}
DirectionType directionType = _playersManager.GetPlayerDirection(consoleWrapper);
if (player.Move(directionType))
{
isInputValid = true;
_playersManager.EatFruits(player, _figures);
_gridManager.DisplayOnGrid(oldPosition);
_gridManager.DisplayOnGrid(player);
moves++;
if (CheckHasPlayerWon(player))
{
break;
}
_gridManager.PrintGrid();
_playersManager.PrintPlayersStatistics();
}
else
{
Console.WriteLine("Wrong input! Please choose a correct direction.");
isInputValid = false;
}
}
}
public void Init()
{
_mockFileInfo = Substitute.For <IFileInfoWrapper>();
_mockFileInfo.Name.Returns("fileInfoName");
_mockFileInfo.FullName.Returns("fullFileName");
_mockFileInfo.CreationTime.Returns(new DateTime(2020, 12, 31));
_mockFileInfo.Extension.Returns(".txt");
_mockConsole = Substitute.For <IConsoleWrapper>();
_mockFile = Substitute.For <IFileWrapper>();
_mockFile.ReadAllText(_mockFileInfo.Name).Returns("5545");
_mockDirectory = Substitute.For <IDirectoryWrapper>();
_mockDirectory.CreateDirectory(_mockFileInfo.Name);
_mockDirectory.GetCreationTime(_mockFileInfo.CreationTime.ToString(CultureInfo.InvariantCulture));
_target = new TxtHandler(_mockFile, _mockFileInfo, _mockConsole, _mockDirectory);
}
private static Task PromptUser(IConsoleWrapper consoleSrv, ILoadServer loaderSrv, CancellationTokenSource cancellationSource)
{
return(Task.Run(() =>
{
do
{
var loadCount = consoleSrv.PromptAndRead("Provide load count...");
if (long.TryParse(loadCount, out var count))
{
loaderSrv.ClientCount(count);
}
if (loadCount.Equals("c", StringComparison.InvariantCultureIgnoreCase) || loadCount.Equals("x", StringComparison.InvariantCultureIgnoreCase))
{
cancellationSource.Cancel();
//Environment.Exit(0);
}
} while (true);
}));
}
public DeploymentModule(
IExceptionHandler exceptionHandler,
IApplicationSettings applicationSettings,
ISystemClock systemClock,
IConsoleWrapper <DeploymentModule> consoleWrapper,
ITargetService targetService,
IDeploymentService deploymentService)
: base(exceptionHandler)
{
ActionDictionary
.Add(builder => builder.Add("add", AddDeployment)
.Add("list", ListDeployments));
DefaultAction = GetDeployment;
RequiresArguments = true;
WriteLineAsyncAction = (format, args, logLevel) => consoleWrapper.WriteLineAsync(format, true, logLevel, args);
this.applicationSettings = applicationSettings;
this.systemClock = systemClock;
this.consoleWrapper = consoleWrapper;
this.targetService = targetService;
this.deploymentService = deploymentService;
}
internal static void HeadlineColorFor(this IConsoleWrapper self, TestUnit unit)
{
switch (unit.Type)
{
case TestUnitType.Assembly:
self.DarkCyan();
self.Underline();
break;
case TestUnitType.Namespace:
self.DarkCyan();
break;
case TestUnitType.Class:
self.DarkGreen();
break;
case TestUnitType.Theory:
break;
}
}
public DirectionType GetPlayerDirection(IConsoleWrapper consoleWrapper)
{
bool isInputValid = true;
DirectionType directionType = DirectionType.Down;
do
{
ConsoleKeyInfo keyInfo = consoleWrapper.ReadKey();
switch (keyInfo.Key)
{
case ConsoleKey.UpArrow:
directionType = DirectionType.Up;
isInputValid = true;
break;
case ConsoleKey.DownArrow:
directionType = DirectionType.Down;
isInputValid = true;
break;
case ConsoleKey.LeftArrow:
directionType = DirectionType.Left;
isInputValid = true;
break;
case ConsoleKey.RightArrow:
directionType = DirectionType.Right;
isInputValid = true;
break;
default:
isInputValid = false;
Console.WriteLine(Environment.NewLine);
Console.WriteLine("Wrong input! Please press some of the arrow keys.");
break;
}
} while (!isInputValid);
return(directionType);
}
public TargetModule(
ISystemClock systemClock,
IExceptionHandler exceptionHandler,
IConsoleWrapper <TargetModule> consoleWrapper,
ICacheState <DateTimeOffset> cacheState,
ITargetTypeService targetTypeService,
ITargetService targetService,
IDeploymentCache deploymentCache)
: base(exceptionHandler)
{
ActionDictionary.Add(builder => builder
.Add("add", AddTarget)
.Add("list", ListTargets));
WriteLineAsyncAction = (format, args, logLevel) => consoleWrapper.WriteLineAsync(format, true, logLevel, args);
DefaultAction = GetTarget;
RequiresArguments = true;
this.systemClock = systemClock;
this.consoleWrapper = consoleWrapper;
this.cacheState = cacheState;
this.targetTypeService = targetTypeService;
this.targetService = targetService;
this.deploymentCache = deploymentCache;
}
public BaseDataCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
: base(console, formatters)
{
this.factory = factory;
this.queries = queries;
}
public ConsoleWriter(IConsoleWrapper consoleWrapper)
{
this.consoleWrapper = consoleWrapper;
}
protected abstract void Write_Foo_In_Blue_To_The_Console(IConsoleWrapper console);
/// <summary>
/// Initializes a new instance of the <see cref="ConsoleView"/> class.
/// </summary>
/// <param name="real">
/// The real view.
/// </param>
/// <param name="consoleWrpView">
/// The console Wrapper View.
/// </param>
public ConsoleView(bool real, IConsoleWrapper<ConsoleColor, ConsoleKeyInfo> consoleWrpView)
{
this.isRealView = real;
this.consoleWrpView = consoleWrpView;
}
protected override void Write_Foo_In_Blue_To_The_Console(IConsoleWrapper console)
{
throw new NotImplementedException();
}
protected abstract object Read_Line_From_Console_And_Return_Value(IConsoleWrapper console);
public JobGithubRepositoryParser(IConsoleWrapper console) : base(console)
{
}
public DirectConsoleWrapper(IConsoleWrapper parentWrapper)
{
_parentWrapper = parentWrapper;
}
public ConsoleReportFactory(IConsoleWrapper wrapper)
{
_wrapper = wrapper;
}
public ProgressNotifier(IConsoleWrapper consoleWrapper)
{
_consoleWrapper = consoleWrapper;
}
public MoveCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
: base(console, factory, queries, formatters)
{
}
public InventoryFormatter(IConsoleWrapper console)
{
this.console = console;
}
public LookFormatter(IConsoleWrapper console)
{
this.console = console;
}
public BaseCommand(IConsoleWrapper console, IFormatter[] formatters)
{
this.console = console;
this.formatters = formatters;
this.commandNames = new List<string>();
}
public NotFoundFormatter(IConsoleWrapper console)
{
this.console = console;
}
public LoginView(IConsoleWrapper console, ISecurityService securityService, ICharacterView characterView)
{
_console = console;
_security = securityService;
_characterView = characterView;
}
protected abstract object Read_Line_From_Console_And_Return_Value(IConsoleWrapper console);
/// <summary>
/// The start main menu.
/// </summary>
/// <param name="output">
/// The output.
/// </param>
public static void StartMainMenu(IConsoleWrapper<ConsoleColor, ConsoleKeyInfo> output)
{
EventHandler ev1 =
(sender, args) => { StartGameMenu(output, new ConsoleView(true, output), new ConsoleTimer()); };
EventHandler ev2 =
(sender, args) => { StartScoresMenu(output, new ConsoleView(false, output), new ConsoleTimer()); };
EventHandler ev3 = (sender, args) =>
{
var help = new StringBuilder();
help.Append("-----------------------------------------------------------");
help.Append("-------------------- MINESWEEPER GAME -------------------");
help.Append("-----------------------------------------------------------");
help.Append(" Version 1.0 ");
help.Append("Telerik Course High Quality Code 2015/2016 ");
var scoreBoxList = new ConsoleBox<ConsoleColor>(
10,
10,
60,
10,
ConsoleColor.Cyan,
ConsoleColor.DarkRed,
help.ToString());
ConsolePrinter.Print(output, scoreBoxList);
output.ReadKey(true);
StartMainMenu(output);
};
EventHandler ev4 = (sender, args) => { Environment.Exit(0); };
DisplayFourItemsMenu("New Game", "High Scores", "Help", "Exit", ev1, ev2, ev3, ev4, output);
}
/// <summary>
/// The display four items menu.
/// </summary>
/// <param name="str1">
/// The string 1.
/// </param>
/// <param name="str2">
/// The string 2.
/// </param>
/// <param name="str3">
/// The string 3.
/// </param>
/// <param name="str4">
/// The string 4.
/// </param>
/// <param name="ev1">
/// The event 1.
/// </param>
/// <param name="ev2">
/// The event 2.
/// </param>
/// <param name="ev3">
/// The event 3.
/// </param>
/// <param name="ev4">
/// The event 4.
/// </param>
/// <param name="output">
/// The output.
/// </param>
private static void DisplayFourItemsMenu(
string str1,
string str2,
string str3,
string str4,
EventHandler ev1,
EventHandler ev2,
EventHandler ev3,
EventHandler ev4,
IConsoleWrapper<ConsoleColor, ConsoleKeyInfo> output)
{
var buttons = new List<ConsoleButton<ConsoleColor>>
{
new ConsoleButton<ConsoleColor>(
20,
3,
ConsoleColor.Blue,
ConsoleColor.Yellow,
ConsoleColor.Yellow,
ConsoleColor.Blue,
str1),
new ConsoleButton<ConsoleColor>(
20,
3,
ConsoleColor.Blue,
ConsoleColor.Yellow,
ConsoleColor.Yellow,
ConsoleColor.Blue,
str2),
new ConsoleButton<ConsoleColor>(
20,
3,
ConsoleColor.Blue,
ConsoleColor.Yellow,
ConsoleColor.Yellow,
ConsoleColor.Blue,
str3),
new ConsoleButton<ConsoleColor>(
20,
3,
ConsoleColor.Blue,
ConsoleColor.Yellow,
ConsoleColor.Yellow,
ConsoleColor.Blue,
str4)
};
buttons[0].ClickEvent += ev1;
buttons[1].ClickEvent += ev2;
buttons[2].ClickEvent += ev3;
buttons[3].ClickEvent += ev4;
output.Clear();
var menu = new ConsoleMenu(25, 10, 1, 1, ConsoleColor.DarkBlue, ConsoleColor.Gray, buttons, output);
menu.Start();
}
protected override object Read_Line_From_Console_And_Return_Value(IConsoleWrapper console)
{
throw new NotImplementedException();
}
/// <summary>
/// The print at console.
/// </summary>
/// <param name="output">
/// The output.
/// </param>
/// <param name="box">
/// The console box.
/// </param>
public static void Print(IConsoleWrapper<ConsoleColor, ConsoleKeyInfo> output, IConsoleBox<ConsoleColor> box)
{
output.SetWindowSize(80, 50);
output.BackgroundColor = box.ColorBackground;
output.ForegroundColor = box.ColorText;
output.SetCursorPosition(5, 2);
output.Write(@"__ __ ___ _ _ _____ ______ _______ _____ ____ _____ ____ ");
output.SetCursorPosition(5, 3);
output.Write(@"| \/ |_ _| \ | | ____/ ___\ \ / / ____| ____| _ \| ____| _ \ ");
output.SetCursorPosition(5, 4);
output.Write(@"| |\/| || || \| | _| \___ \\ \ /\ / /| _| | _| | |_) | _| | |_) |");
output.SetCursorPosition(5, 5);
output.Write(@"| | | || || |\ | |___ ___) |\ V V / | |___| |___| __/| |___| _ < ");
output.SetCursorPosition(5, 6);
output.Write(@"|_| |_|___|_| \_|_____|____/ \_/\_/ |_____|_____|_| |_____|_| \_\");
for (var i = box.StartX; i <= box.StartX + box.SizeX; i++)
{
for (var j = box.StartY; j <= box.StartY + box.SizeY; j++)
{
output.SetCursorPosition(i, j);
output.Write(" ");
}
}
output.SetCursorPosition(box.StartX, box.StartY);
output.Write("╔");
output.SetCursorPosition(box.StartX, box.StartY + box.SizeY);
output.Write("╚");
output.SetCursorPosition(box.StartX + box.SizeX, box.StartY);
output.Write("╗");
output.SetCursorPosition(box.StartX + box.SizeX, box.StartY + box.SizeY);
output.Write("╝");
for (var i = box.StartX + 1; i < box.StartX + box.SizeX; i++)
{
output.SetCursorPosition(i, box.StartY);
output.Write("═");
output.SetCursorPosition(i, box.StartY + box.SizeY);
output.Write("═");
}
for (var i = box.StartY + 1; i < box.StartY + box.SizeY; i++)
{
output.SetCursorPosition(box.StartX, i);
output.Write("║");
output.SetCursorPosition(box.StartX + box.SizeX, i);
output.Write("║");
}
if (box.Text != string.Empty)
{
var rows = box.Text.SplitBy(box.SizeX - 1);
var cnt = 0;
foreach (var row in rows)
{
output.SetCursorPosition(box.StartX + 1, box.StartY + 1 + cnt);
output.Write(row);
cnt++;
}
}
output.ResetColor();
}
protected override void BeforeEachTest()
{
base.BeforeEachTest();
console = MockRepository.GenerateMock<IConsoleWrapper>();
}
/// <summary>
/// Initializes a new instance of the <see cref="HumanPlayer"/> class.
/// </summary>
/// <param name="consoleWrapper">The <see cref="IConsoleWrapper"/>.</param>
/// <param name="name">The player name.</param>
public HumanPlayer(IConsoleWrapper consoleWrapper, string name)
: base(name)
{
_consoleWrapper = consoleWrapper ?? throw new ArgumentNullException(nameof(consoleWrapper));
}
protected abstract void Write_FooBar_To_The_Console(IConsoleWrapper console);
/// <summary>
/// The print grid.
/// </summary>
/// <param name="output">
/// The output.
/// </param>
/// <param name="box">
/// The console box.
/// </param>
/// <param name="openCellEvent">
/// The open cell event.
/// </param>
/// <param name="protectCellEvent">
/// The protect cell event.
/// </param>
public static void PrintGrid(
IConsoleWrapper<ConsoleColor, ConsoleKeyInfo> output,
IConsoleBox<ConsoleColor> box,
EventHandler openCellEvent,
EventHandler protectCellEvent)
{
Print(output, box);
var x = box.StartX + 1;
var y = box.StartY + 1;
output.CursorVisible = true;
output.CursorSize = 100;
output.SetCursorPosition(x, y);
ConsoleKeyInfo key;
do
{
key = output.ReadKey(true);
if (key.Key == ConsoleKey.RightArrow)
{
if (x < box.StartX + box.SizeX - 1)
{
x += 1;
}
}
if (key.Key == ConsoleKey.DownArrow)
{
if (y < box.StartY + box.SizeY - 1)
{
y += 1;
}
}
if (key.Key == ConsoleKey.LeftArrow)
{
if (x > box.StartX + 1)
{
x -= 1;
}
}
if (key.Key == ConsoleKey.UpArrow)
{
if (y > box.StartY + 1)
{
y -= 1;
}
}
if (key.Key == ConsoleKey.Spacebar)
{
var args = new MinesweeperCellClickEventArgs { Row = y - box.StartY - 1, Col = x - box.StartX - 1 };
openCellEvent.Invoke(null, args);
}
if (key.Key == ConsoleKey.F)
{
var args = new MinesweeperCellClickEventArgs { Row = y - box.StartY - 1, Col = x - box.StartX - 1 };
protectCellEvent.Invoke(null, args);
}
output.SetCursorPosition(x, y);
}
while (key.Key != ConsoleKey.End);
}
public GameInterfaceManagerTests()
{
_vectorProvider = new VectorProvider();
_consoleWrapperMock = Substitute.For <IConsoleWrapper>();
}
public ApplicationService(INewsService newsService, ILoggerFactory loggerFactory, IConsoleWrapper console)
{
_newsService = newsService;
_logger = loggerFactory.CreateLogger(GetType());
_console = console;
}
public GameEngine(IConsoleWrapper console, ICommand[] cmdList)
{
this.cmdList = cmdList;
this.console = console;
}
public ILogger CreateConsoleLogger(IConsoleWrapper consoleWrapper)
{
return(new ConsoleLogger(consoleWrapper, _dateTimeProvider));
}
public Ship(string playerName, int shipLength, ICoordinatesReader coordinateReader, IConsoleWrapper console)
{
if (coordinateReader == null)
{
throw new ArgumentNullException(nameof(coordinateReader));
}
if (console == null)
{
throw new ArgumentNullException(nameof(console));
}
if (string.IsNullOrWhiteSpace(playerName))
{
throw new ArgumentException(nameof(playerName));
}
if (shipLength != 3)
{
throw new ArgumentException(nameof(shipLength));
}
_coordinateReader = coordinateReader;
_console = console;
PlayerName = playerName;
ShipLength = shipLength;
CoordinatesList = new List <Coordinates>();
HitShots = new List <Coordinates>();
MissedShots = new List <Coordinates>();
}
public CreateExitCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
: base(console, factory, queries, formatters)
{
AddCommandName("@createexit");
AddCommandName("@ce");
}
public LookCommand(IConsoleWrapper console, IRepositoryFactoryFactory factory, IGameObjectQueries queries, IFormatter[] formatters)
: base(console, factory, queries, formatters)
{
AddCommandName("look");
AddCommandName("l");
}
public ConsoleLogger(LogType logVerbosity, IConsoleWrapper consoleWrapper)
{
this.LogVerbosity = logVerbosity;
this.consoleWrapper = consoleWrapper;
}
