private static string[] FormatRenderer(ColumnFormat format, IConsoleRenderer value, int columnWidth, int tabLength, int firstLineHangingIndent) { var headingText = MakeHeading(format, columnWidth, tabLength, firstLineHangingIndent); int wrappedLines; var renderedData = value.Render(columnWidth, out wrappedLines); return headingText.Concat(renderedData).ToArray(); }
public DevConsole(Game game, IConsoleRenderer renderer) : base(game) { Renderer = renderer ?? throw new ArgumentNullException(nameof(renderer)); InputManager = new ConsoleInputManager(Game); Game.Components.Add(InputManager); Game.Components.Add(this); }
public Engine(ICommandParser commandParser, ICommandProcessor commandProcessor, IConsoleRenderer consoleRenderer, IFileManager fileManager) { this.commandParser = commandParser; this.commandProcessor = commandProcessor; this.consoleRenderer = consoleRenderer; this.fileManager = fileManager; }
protected CommandBase(IConsoleRenderer renderer, PartyConfiguration config, IPartyControllerFactory controllerFactory, CommonArguments args) { Renderer = renderer; Config = GetConfig(config, args.VaM); Logger = args.Log == LogLevel.Disabled ? (ILogger) new NullLogger() : new AccumulatorLogger(args.Log); Controller = controllerFactory.Create(Config, Logger, !args.Force); }
protected CommandBase(IConsoleRenderer renderer, PartyConfiguration config, IPartyController controller, CommonArguments args) { Renderer = renderer; Config = GetConfig(config, args.VaM); Controller = controller; Controller.ChecksEnabled = args.Force; }
public CosmeticsEngine(IDataStore dataStore, IConsoleRenderer consoleRenderer, ICommandsFactory commandsFactory) { this.dataStore = dataStore; this.commandsFactory = commandsFactory; this.consoleRenderer = consoleRenderer; }
public void TestConsoleRendererInstance() { IConsoleRenderer testConsRenderer = new ConsoleRenderer(); IConsoleRenderer factoryConsRenderer = testConsoleGraphicFactory.GetConsoleRenderer(); Object.Equals(testConsRenderer, factoryConsRenderer); }
public AgateConsole(IConsoleRenderer renderer) { this.renderer = renderer; renderer.State = shell.State; keyboardInput.KeyPress += KeyboardInput_KeyPress; }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyControllerFactory controllerFactory) { return(new Command("help", "Show useful information about party") { Handler = CommandHandler.Create <HelpArguments>(args => new HelpCommand(renderer, config, controllerFactory, args).ExecuteAsync(args)) }); }
/// <summary> /// Gets the correct instance of the class implementing <see cref="IScene"/> interface. /// </summary> /// <returns>The correct instance of the class implementing <see cref="IScene"/> interface</returns> /// <param name="renderer">A non null value of <see cref="IConsoleRenderer"/></param> public IScene GetISceneInstance(IConsoleRenderer renderer) { if (renderer == null) { throw new ArgumentNullException(); } return(new ConsoleScene(renderer)); }
public Game(IConsoleRenderer renderer, IRandomWordGenerator generator, ICommandManager commandManager) { this.renderer = renderer; this.generator = generator; this.commandManager = commandManager; this.scoreManager = ScoreManager.Instance; InitializeGameSettings(); }
uint vehicleSpeed; //"iteration % vehicleSpeed == 0" and this.iteration is ++ed on each iteration #endregion Fields #region Constructors //but for performance reasons, we'll make it 30 public Engine(IConsoleRenderer renderer, IUserInterface userInterface, //the game will practically run on sleepTime = 0 int lives = 5, uint vehicleSpeed = 15, int sleepTime = 20) { this.renderer = renderer; this.userInterface = userInterface; this.lives = lives; this.vehicleSpeed = vehicleSpeed; this.SleepTime = sleepTime; this.allObjects = new List<GameObject>(); }
/// <summary> /// Creates a new console menu handler /// </summary> /// <param name="inputProvider">Input provider</param> /// <param name="renderer">Renderer</param> /// <param name="menuItems">Menu items</param> /// <param name="menuTop">Menu rendering top row</param> /// <param name="menuLeft">Menu rendering left col</param> public ConsoleMenuHandler(IConsoleInputProvider inputProvider, IConsoleRenderer renderer, IEnumerable<IGameMode> menuItems, int menuTop, int menuLeft) { this.inputProvider = inputProvider; this.renderer = renderer; this.currentSelection = new BeginnerMode(); this.menuItems = menuItems; this.menuBodyTop = menuTop + RenderersConstants.MenuTitleRowsCount; this.menuBodyLeft = menuLeft; this.selectionCharTop = menuTop + RenderersConstants.MenuTitleRowsCount; this.selectionCharLeft = this.menuBodyLeft; }
public RegionCreationOptions(IConsoleRenderer renderer, DotConsoleRegion parent, Coordinates bufferSize) { this.Renderer = renderer; this.Parent = parent; this.BufferSize = bufferSize; this.Orgin = default(Coordinates); this.WillScrollContent = false; this.ForegroundColor = new Color(255, 255, 255); this.BackgroundColor = new Color(0, 0, 100); this.Position = DotConsoleRegion.ContentPosition.Top; this.IsVisible = true; }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyControllerFactory controllerFactory) { var command = new Command("show", "Show information about a package"); AddCommonOptions(command); command.AddArgument(new Argument <string>("package", null)); command.Handler = CommandHandler.Create <ShowArguments>(async args => { await new ShowCommand(renderer, config, controllerFactory, args).ExecuteAsync(args); }); return(command); }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyControllerFactory controllerFactory) { var command = new Command("search", "Search for packages in the registry"); AddCommonOptions(command); command.AddArgument(new Argument <string>("query", null)); command.Handler = CommandHandler.Create <SearchArguments>(async args => { await new SearchCommand(renderer, config, controllerFactory, args).ExecuteAsync(args); }); return(command); }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyController controller) { var command = new Command("show", "Show information about a package"); AddCommonOptions(command); command.AddArgument(new Argument <string>("package", null)); command.AddOption(new Option("--warnings", "Show warnings such as broken scenes or missing scripts")); command.Handler = CommandHandler.Create <ShowArguments>(async args => { await new ShowCommand(renderer, config, controller, args).ExecuteAsync(args); }); return(command); }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyController controller) { var command = new Command("search", "Search for packages in the registry"); AddCommonOptions(command); command.AddArgument(new Argument <string>("query", null)); command.AddOption(new Option("--no-usage", "Do not show usage information from scenes (runs faster)")); command.AddOption(new Option("--warnings", "Show warnings such as broken scenes or missing scripts")); command.Handler = CommandHandler.Create <SearchArguments>(async args => { await new SearchCommand(renderer, config, controller, args).ExecuteAsync(args); }); return(command); }
/// <summary> /// Initializes a new instance of the <see cref="CakeBuildLog" /> class. /// </summary> /// <param name="console">The console.</param> /// <param name="verbosity">The verbosity.</param> public CakeBuildLog(IConsole console, Verbosity verbosity = Verbosity.Normal) { _console = console; _lock = new object(); if (_console.SupportAnsiEscapeCodes) { // Use ANSI console renderer. _renderer = new AnsiConsoleRenderer(_console); } else { // Use the default renderer. _renderer = new ConsoleRenderer(_console); } Verbosity = verbosity; }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyControllerFactory controllerFactory) { var command = new Command("get", "Downloads a package (script, morph or scene) into the saves folder"); AddCommonOptions(command); command.AddArgument(new Argument <string>("packages", null) { Description = "The package, in the format scripts/name or scripts/[email protected]", Arity = ArgumentArity.ZeroOrMore }); command.AddOption(new Option("--noop", "Do not install, just check what it will do")); command.AddOption(new Option("--all", "Install the latest version of everything").WithAlias("-a")); command.Handler = CommandHandler.Create <GetArguments>(async args => { await new GetCommand(renderer, config, controllerFactory, args).ExecuteAsync(args); }); return(command); }
/// <summary> /// Initializes a new instance of the <see cref="GameEngine"/> class /// </summary> /// <param name="width">Integer value for the width</param> /// <param name="height">Integer value for the height</param> /// <param name="factory">A non null instance of <see cref="IFactory"/></param> public GameEngine(int width, int height, IFactory factory) { if (width < 1) { throw new ArgumentException("The value of the width must be more than 0"); } if (height < 1) { throw new ArgumentException("The value of the height must be more than 0"); } if (factory == null) { throw new ArgumentNullException("The factory must not be null"); } this.windowWidth = width; this.windowHeight = height; this.factory = factory; this.input = this.factory.GetIUserInputInstance(); this.labyrinth = this.factory.GetILabyrinthPlayFieldInstance(factory, this.factory.GetIMoveHandlerInstance()); this.gameConsole = this.factory.GetIGameConsoleInstance(this.factory.GetILanguageStringsInstance()); this.resultsTable = this.factory.GetIResultsTableInstance(); this.resultsTable.Table.Changed += (sender, e) => { this.factory.GetFileSerializationManagerInstance().Serialize(sender); }; var fileAppender = this.factory.GetFileIAppenderInstance("Log.txt"); this.simpleLoggerFileAppender = this.factory.GetSimpleILoggerInstance(fileAppender); this.consoleGraphicFactory = this.factory.GetIConsoleGraphicFactoryInstance(); this.renderer = this.consoleGraphicFactory.GetConsoleRenderer(); this.scene = this.factory.GetISceneInstance(this.renderer); this.labyrinthGraphic = this.consoleGraphicFactory.GetLabyrinthConsoleGraphic(this.labyrinth, this.consoleGraphicFactory.GetCoordinates(2, 1), this.renderer); this.gameConsoleGraphic = this.consoleGraphicFactory.GetGameConsoleGraphic(this.gameConsole, this.consoleGraphicFactory.GetCoordinates(2, this.labyrinth.LabyrinthSize + 2), this.renderer); this.tableGraphic = this.consoleGraphicFactory.GetResultsTableConsoleGraphic(this.resultsTable, this.consoleGraphicFactory.GetCoordinates(2, 1), this.renderer); this.gameLogic = factory.GetIGameLogicInstance(this.labyrinth, this.gameConsole, this.resultsTable, this.input, this.factory); }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyControllerFactory controllerFactory) { var command = new Command("status", "Shows the state of the current scripts and scenes"); AddCommonOptions(command); command.AddArgument(new Argument <string>("filter") { Arity = ArgumentArity.ZeroOrOne }); command.AddOption(new Option("--breakdown", "Show the list of scenes and files for each script").WithAlias("-b")); command.AddOption(new Option("--errors", "Show warnings such as broken scenes or missing scripts").WithAlias("-e")); command.AddOption(new Option("--unregistered", "Show all scripts that were not registered").WithAlias("-u")); command.Handler = CommandHandler.Create <StatusArguments>(async args => { await new StatusCommand(renderer, config, controllerFactory, args).ExecuteAsync(args); }); return(command); }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyController controller) { var command = new Command("upgrade", "Updates scenes to reference scripts from the Party folder. You can specify a package, scene or script to upgrade. If you don't specify anything, all scenes and scripts will be upgraded."); AddCommonOptions(command); // TODO: Specify specific scenes and/or specific scripts and/or specific packages to upgrade command.AddArgument(new Argument <string>("filter")); command.AddOption(new Option("--all", "Upgrade everything")); command.AddOption(new Option("--get", "Downloads registered scripts that were not already downloaded")); command.AddOption(new Option("--fix", "Updates scenes referencing scripts that are not yet in the party folder")); command.AddOption(new Option("--clean", "Deletes the source script after scenes have been updated")); command.AddOption(new Option("--warnings", "Show warnings such as broken scenes or missing scripts")); command.AddOption(new Option("--noop", "Prints what the script will do, but won't actually do anything")); command.AddOption(new Option("--verbose", "Prints every change that will be done on every scene")); command.Handler = CommandHandler.Create <UpgradeArguments>(async args => { await new UpgradeCommand(renderer, config, controller, args).ExecuteAsync(args); }); return(command); }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyController controller) { var command = new Command("get", "Downloads a package (script, morph or scene) into the saves folder"); AddCommonOptions(command); command.AddArgument(new Argument <string>("package", null) { Arity = ArgumentArity.ExactlyOne }); command.AddOption(new Option("--version", "Choose a specific version to install") { Argument = new Argument <string>() }); command.AddOption(new Option("--noop", "Do not install, just check what it will do")); command.Handler = CommandHandler.Create <GetArguments>(async args => { await new GetCommand(renderer, config, controller, args).ExecuteAsync(args); }); return(command); }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyControllerFactory controllerFactory) { var command = new Command("upgrade", "Updates scenes to reference scripts from the Party folder. You can specify a package, scene or script to upgrade. If you don't specify anything, all scenes and scripts will be upgraded."); AddCommonOptions(command); command.AddArgument(new Argument <string>("filter") { Arity = ArgumentArity.ZeroOrOne }); command.AddOption(new Option("--all", "Upgrade everything").WithAlias("-a")); command.AddOption(new Option("--major", "Allows upgrading even with major versions").WithAlias("-m")); command.AddOption(new Option("--errors", "Show warnings such as broken scenes or missing scripts").WithAlias("-e")); command.AddOption(new Option("--noop", "Prints what the script will do, but won't actually do anything")); command.AddOption(new Option("--verbose", "Prints every change that will be done on every scene").WithAlias("-v")); command.Handler = CommandHandler.Create <UpgradeArguments>(async args => { await new UpgradeCommand(renderer, config, controllerFactory, args).ExecuteAsync(args); }); return(command); }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyControllerFactory controllerFactory) { var command = new Command("clean", "Updates scenes to reference scripts from their expected folder. You can specify a specific script or scene to clean."); AddCommonOptions(command); command.AddArgument(new Argument <string>("filter") { Arity = ArgumentArity.ZeroOrOne, Description = "Optional package name or file to clean" }); command.AddOption(new Option("--all", "Upgrade everything").WithAlias("-a")); command.AddOption(new Option("--errors", "Show warnings such as broken scenes or missing scripts").WithAlias("-e")); command.AddOption(new Option("--noop", "Prints what the script will do, but won't actually do anything")); command.AddOption(new Option("--delete-unused", "Deletes unused scripts").WithAlias("-d")); command.AddOption(new Option("--verbose", "Prints every change that will be done on every scene").WithAlias("-v")); command.Handler = CommandHandler.Create <CleanArguments>(async args => { await new CleanCommand(renderer, config, controllerFactory, args).ExecuteAsync(args); }); return(command); }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyControllerFactory controllerFactory) { var command = new Command("publish", "Prepares files for publishing (using a folder, a list of files or a list of urls)"); AddCommonOptions(command); command.AddArgument(new Argument <string>("input", null) { Arity = ArgumentArity.OneOrMore }); command.AddOption(new Option("--package-name", "The name of your package") { Argument = new Argument <string>() }.WithAlias("-pn")); command.AddOption(new Option("--package-version", "The version of your package") { Argument = new Argument <string>() }.WithAlias("-v")); command.AddOption(new Option("--package-author", "The author name of your package") { Argument = new Argument <string>() }.WithAlias("-pa")); command.AddOption(new Option("--package-version-download-url", "The url to download this version") { Argument = new Argument <string>() }.WithAlias("-pu")); command.AddOption(new Option("--registry", "Path the the index.json file of your locally cloned registry") { Argument = new Argument <FileInfo>().ExistingOnly() }.WithAlias("-r")); command.AddOption(new Option("--quiet", "Just print the hash and metadata, no questions asked").WithAlias("-q")); command.AddOption(new Option("--format", "Just format the registry, e.g. after manually editing it").WithAlias("-fmt")); command.Handler = CommandHandler.Create <PublishArguments>(async args => { await new PublishCommand(renderer, config, controllerFactory, args).ExecuteAsync(args); }); return(command); }
public static Command CreateCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyController controller) { var command = new Command("publish", "Prepares files for publishing (using a folder, a list of files or a list of urls)"); AddCommonOptions(command); command.AddArgument(new Argument <string>("input", null) { Arity = ArgumentArity.OneOrMore }); command.AddOption(new Option("--package-name", "The name of your package") { Argument = new Argument <string>() }); command.AddOption(new Option("--package-version", "The version of your package") { Argument = new Argument <string>() }); command.AddOption(new Option("--package-author", "The author name of your package") { Argument = new Argument <string>() }); command.AddOption(new Option("--registry", "Path the the index.json file of your locally cloned registry") { Argument = new Argument <FileInfo>().ExistingOnly() }); command.AddOption(new Option("--saves", "Specify a custom saves folder, e.g. when the script is not in the Virt-A-Mate folder") { Argument = new Argument <DirectoryInfo>().ExistingOnly() }); command.AddOption(new Option("--quiet", "Just print the hash and metadata, no questions asked")); command.Handler = CommandHandler.Create <PublishArguments>(async args => { await new PublishCommand(renderer, config, controller, args).ExecuteAsync(args); }); return(command); }
public static ColoredConsoleRx Create(IConsoleRenderer renderer) { return(new ColoredConsoleRx(renderer)); }
public ShowCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyControllerFactory controllerFactory, CommonArguments args) : base(renderer, config, controllerFactory, args) { }
/// <summary> /// Start Game logic /// </summary> public void Start() { // Initialize the two basic objects needed for user interactions this.InputProvider = this.inputProvider ?? new ConsoleInputProvider(); this.OutputRenderer = this.outputRenderer ?? new ConsoleRenderer(); // Render initial UI this.OutputRenderer.RenderWelcomeScreen(string.Join(string.Empty, RenderersConstants.GameTitle)); this.OutputRenderer.RenderNewPlayerCreationRequest(); // Create the active player var player = new Player(this.InputProvider.ReceiveInputLine()); // Render console menu handler and execute logic for requesting board settings // TODO: Refactor menu handler logic int[] cursorPosition = this.OutputRenderer.GetCursor(); var menuItems = new List<IGameMode>() { new BeginnerMode(), new IntermediateMode(), new ExpertMode() }; var menuHandler = new ConsoleMenuHandler(this.inputProvider, this.outputRenderer, menuItems, cursorPosition[0] + 1, cursorPosition[1]); menuHandler.ShowSelections(); BoardSettings boardSettings = menuHandler.RequestUserSelection(); this.OutputRenderer.ClearScreen(); this.OutputRenderer.SetCursor(visible: true); //// End of menu handler logic var board = new Board(boardSettings, new List<IBoardObserver>()); var scoreboard = new Scoreboard(); var contentFactory = new ContentFactory(); var initializationStrategy = new StandardGameInitializationStrategy(contentFactory); var boardOperator = new CommandOperator(board, scoreboard); var engine = new StandardOnePlayerMinesweeperEngine(board, this.inputProvider, this.outputRenderer, boardOperator, scoreboard, player); engine.Initialize(initializationStrategy); board.Subscribe(engine); engine.Run(); }
public GetCommand(IConsoleRenderer renderer, PartyConfiguration config, IPartyController controller, CommonArguments args) : base(renderer, config, controller, args) { }
public CommandManager(ICommandParser parser, IConsoleRenderer renderer) { this.parser = parser; this.renderer = renderer; scoreManager = ScoreManager.Instance; }
public ColoredConsoleRx(IConsoleRenderer renderer) { _renderer = renderer; }
public Program(IConsoleRenderer renderer, PartyConfiguration config, IPartyController controller) { _renderer = renderer; _config = config; _controller = controller; }
public RenderCommand(IConsoleRenderer data) { _data = data; }
/// <summary> /// Construct from an object derived from <see cref="IConsoleRenderer"/>. /// </summary> public FormattingIntermediate(IConsoleRenderer renderableValue) { RenderableValue = renderableValue; }
/// <summary> /// Initializes a new instance of the <see cref="ConsoleScene" /> class. /// </summary> /// <param name="renderer">Renderer for the scene.</param> public ConsoleScene(IConsoleRenderer renderer) : base() { this.renderer = renderer; }