public PopBalloonsCommand(IBalloonsFactory balloonsFactory, IGameField gameField, int activeRow, int activeCol) { this.balloonsFactory = balloonsFactory; this.gameField = gameField; this.activeRow = activeRow; this.activeCol = activeCol; this.Name = "pop"; }
public void Setup() { this.renderer = new ConsoleRenderer(); this.field = new GameField(2, 2); this.fieldMemoryManager = new FieldMemoryManager(); this.balloonsFactory = new BalloonsFactory(); this.field[0, 0] = new BalloonOne(); this.field[0, 1] = new BalloonTwo(); this.field[1, 0] = new BalloonThree(); this.field[1, 1] = new BalloonFour(); }
private void SwapWithNextUnpopedBalloon(IGameField gameField, int activeRow, int activeCol, int rows) { for (int row = activeRow + 1; row < rows; row++) { if (gameField[row, activeCol].Symbol != GameConstants.PopedBalloonSymbol) { var oldValue = gameField[activeRow, activeCol]; gameField[activeRow, activeCol] = gameField[row, activeCol]; gameField[row, activeCol] = oldValue; return; } } }
/// <summary> /// Simulates one step in the Game of Life. /// </summary> /// <param name="oldGameField">The IGameField from the last simulation step.</param> /// <param name="newGameField">The IGameField to fill with this simulation step.</param> public void SimulateStep( IGameField oldGameField, IGameField newGameField ) { Debug.Assert( oldGameField.Width == newGameField.Width ); Debug.Assert( oldGameField.Height == newGameField.Height ); int width = oldGameField.Width; int height = oldGameField.Height; for( int x = 0; x < width; ++x ) { for( int y = 0; y < height; ++y ) { newGameField.SetCellState( x, y, this.SimulateCell( x, y, oldGameField ) ); } } }
/// <summary> /// Gets how many 'alive' neighbors the given cell has. /// </summary> /// <param name="x">The position of the cell on the x-axis.</param> /// <param name="y">The position of the cell on the y-axis.</param> /// <param name="gameField">The IGameField to pull the data from.</param> /// <returns> /// The number of alive neighbors. /// </returns> private int GetAliveNeighborCount( int x, int y, IGameField gameField ) { int count = 0; count += this.GetCellState( x + 1, y, gameField ); count += this.GetCellState( x - 1, y, gameField ); count += this.GetCellState( x, y + 1, gameField ); count += this.GetCellState( x, y - 1, gameField ); count += this.GetCellState( x + 1, y + 1, gameField ); count += this.GetCellState( x + 1, y - 1, gameField ); count += this.GetCellState( x - 1, y - 1, gameField ); count += this.GetCellState( x - 1, y + 1, gameField ); return count; }
private void StartInteraction(IGameField field) { string readBuffer = null; int blownMines = 0; while (field.ContainsMines()) { try { field.DrawField(); Console.Write(GameMessage.CoordinatesPrompt); readBuffer = Console.ReadLine(); Mine mineToBlow = GameServices.ExtractMineFromString(readBuffer); while (mineToBlow == null) { Console.Write(GameMessage.CoordinatesPrompt); readBuffer = Console.ReadLine(); mineToBlow = GameServices.ExtractMineFromString(readBuffer); } bool isValidMove = GameServices.IsValidMove(field.Field, mineToBlow.X, mineToBlow.Y); if (!isValidMove) { Console.WriteLine(GameMessage.InvalidMove); continue; } Explosion.Explode(field.Field, mineToBlow); blownMines++; } catch (InvalidMineCoordinatesException) { Console.WriteLine(GameMessage.InvalidIndex); continue; } } field.DrawField(); Console.WriteLine("{0} {1}", GameMessage.GameOverMessage, blownMines); }
/// <summary> /// Orders matrix cells that have numbers in them in a smaller row number and those with "." at a bigger row. /// </summary> /// <param name="gameField">Field to reorder.</param> public override void ReorderBalloons(IGameField gameField) { if (ObjectValidator.IsGameObjectNull(gameField)) { throw new ArgumentNullException(FieldNullErrorMessage); } int rows = gameField.Rows; int columns = gameField.Columns; for (int col = 0; col < columns; col++) { for (int row = 0; row < rows; row++) { if (gameField[row, col].Symbol == GameConstants.PopedBalloonSymbol) { this.SwapWithNextUnpopedBalloon(gameField, row, col, rows); } } } }
/// <summary> /// Simulates the state of the cell at the given position. /// </summary> /// <param name="x">The position of the cell on the x-axis.</param> /// <param name="y">The position of the cell on the y-axis.</param> /// <param name="gameField">The IGameField to pull the data from.</param> /// <returns> /// Whether the given cell is 'dead' or 'alive'. /// </returns> private bool SimulateCell( int x, int y, IGameField gameField ) { int neighborCount = this.GetAliveNeighborCount( x, y, gameField ); if( gameField.GetCellStateStrict( x, y ) ) { // For a space that is 'populated': // Each cell with one or no neighbors dies, as if by loneliness. // Each cell with four or more neighbors dies, as if by overpopulation. // Each cell with two or three neighbors survives. return neighborCount == 2 || neighborCount == 3; } else { // For a space that is 'empty' or 'unpopulated' // Each cell with three neighbors becomes populated. return neighborCount == 3; } }
private void Pop(int activeRow, int activeCol, string activeCell, IGameField field) { bool isValidPop = this.IsPopValid(activeRow, field.Rows) && this.IsPopValid(activeCol, field.Columns); if (isValidPop && (field[activeRow, activeCol].Symbol == activeCell) && (field[activeRow, activeCol].Symbol != GameConstants.PopedBalloonSymbol)) { field[activeRow, activeCol] = this.balloonsFactory.GetBalloon(GameConstants.PopedBalloonSymbol); // Up this.Pop(activeRow - 1, activeCol, activeCell, field); // Down this.Pop(activeRow + 1, activeCol, activeCell, field); // Left this.Pop(activeRow, activeCol + 1, activeCell, field); // Right this.Pop(activeRow, activeCol - 1, activeCell, field); } }
public bool CheckPossibilityToKill(Coord CurrentCoord, Coord DestCoord, IGameField field) { if (DestCoord.Row < 1 || DestCoord.Row > 8 || DestCoord.Column < 1 || DestCoord.Column > 8) { return(false); //за пределы поля } if (field.Grid[DestCoord.Row][DestCoord.Column] != null) { return(false); //там занято } int dRow = DestCoord.Row - CurrentCoord.Row; int dColumn = DestCoord.Column - CurrentCoord.Column; if (Math.Abs(dRow) == 2 && Math.Abs(dColumn) == 2) //если хотим бить { IChecker neigbour = field.Grid[CurrentCoord.Row + dRow / 2][CurrentCoord.Column + dColumn / 2]; //ищем кого бить if (neigbour != null && neigbour is WhiteChecker) //если там враг { return(true); } } return(false); }
private void MakeBorders(IGameField gameField) { int rows = gameField.Board.GetLength(0); int columns = gameField.Board.GetLength(1); base.Engine.Writer.WriteLine("\n 0 1 2 3 4 5 6 7 8 9"); base.Engine.Writer.WriteLine(" ---------------------"); for (int row = 0; row < rows; row++) { base.Engine.Writer.Write(string.Format("{0} | ", row)); for (int col = 0; col < columns; col++) { base.Engine.Writer.Write(string.Format("{0} ", gameField.Board[row, col])); } base.Engine.Writer.Write("|"); Console.WriteLine(); } base.Engine.Writer.WriteLine(" ---------------------\n"); }
public override bool CanMove(GameSide side, IGameField field) { switch (side) { case GameSide.Left: if (_gameBlock.Right.Column == 0) { return(false); } return(field[_gameBlock.Right.Row, _gameBlock.Right.Column - 1].Type == GameCellType.None); case GameSide.Right: if (_gameBlock.Left.Column + 1 == field.Width) { return(false); } return(field[_gameBlock.Left.Row, _gameBlock.Left.Column + 1].Type == GameCellType.None); case GameSide.Down: return(_gameBlock.Left.CanFallDown(field) && _gameBlock.Right.CanFallDown(field)); default: throw new ArgumentException("Неверно указана сторона side (GameSide)"); } }
public IChecker GetVictim(Coord CurrentCoord, Coord DestCoord, IGameField field) { if (DestCoord.Row < 1 || DestCoord.Row > 8 || DestCoord.Column < 1 || DestCoord.Column > 8) { return(null); //за пределы поля } if (field.Grid[DestCoord.Row][DestCoord.Column] != null) { return(null); //там занято } int dRow = DestCoord.Row - CurrentCoord.Row; int dColumn = DestCoord.Column - CurrentCoord.Column; if (Math.Abs(dRow) == 2 && Math.Abs(dColumn) == 2) //если хотим бить { IChecker neigbour = field.Grid[CurrentCoord.Row + dRow / 2][CurrentCoord.Column + dColumn / 2]; //ищем кого бить if (neigbour != null && neigbour is BlackChecker) //если там враг { return(neigbour); } } return(null); }
//Init private void InitGame() { _pool = new GamePool(_blockPrefab, _config.fieldWidth * _config.fieldHeight); _field = new GameField(_config, _pool); _uIManager = new UIManager(GameObject.Find("Canvas").transform); }
/// <summary> /// Initializes a new instance of the <see cref="ExplosionHandler" /> class. /// </summary> /// <param name="gameField">Accepts an instance of the game field.</param> public ExplosionHandler(IGameField gameField) { this.FieldBlastRepresentation = DEFAULT_FIELD_BLAST_REPRESENTATION; this.GameField = gameField; }
public SlowPokeWarsGame(IGameField gameField) { _gameGuid = Guid.NewGuid(); _gameField = gameField; }
public RandomPlayer(IGameField selfField) : base(selfField) { }
protected PlayerBase(IGameField selfField) { SelfField = selfField; OpponentFieldKnowledge = new GameFieldKnowledge(SelfField.Size); }
public override bool CanTurn(IGameField field) { return(_gameBlock.Left.Column > 0 && field[_gameBlock.Left.Row + 1, _gameBlock.Left.Column - 1].Type == GameCellType.None); }
public void Setup() { this.renderer = new ConsoleRenderer(); this.field = new GameField(5, 5); this.fieldMemoryManager = new FieldMemoryManager(); this.balloonsFactory = new BalloonsFactory(); }
public void AcceptField(IGameField field) { _field = field; _field.AddObject(this); }
/// <summary> /// Refreshes the cell at the given position. /// </summary> /// <param name="x">The position of the cell on the x-axis.</param> /// <param name="y">The position of the cell on the y-axis.</param> /// <param name="gameField">The IGameField to pull the data from.</param> private void RefreshCell( int x, int y, IGameField gameField ) { bool isAlive = gameField.GetCellStateStrict( x, y ); Brush brush = this.GetBrush( isAlive ); Rectangle rect = this.cellField[x, y]; if( rect.Fill != brush ) { rect.Fill = brush; } }
/// <summary> /// Refreshes this IGameFieldView based on the given IGameField. /// </summary> /// <param name="gameField"> /// The IGameField to 'visualize'. /// </param> public void Refresh( IGameField gameField ) { int width = gameField.Width; int height = gameField.Height; for( int x = 0; x < width; ++x ) { for( int y = 0; y < height; ++y ) { this.RefreshCell( x, y, gameField ); } } }
public SaveCommand(IFieldMemoryManager fieldMemoryManager, IGameField field) { this.field = field; this.fieldMemoryManager = fieldMemoryManager; this.Name = "save"; }
public void AddField(IGameField field) { this.allfields.Add(field); }
private void PrepareNewGameRound(IFieldFactory fieldFactory, GameDifficulty gameDifficulty) { this.field = fieldFactory.CreateGameField(gameDifficulty); this.field.Filler = this.engineContext.GameFieldFiller; this.field.Fill(); }
public IChecker GetVictim(Coord coord, IGameField field) { return(CheckerState.GetVictim(CurrentCoord, coord, field)); }
public bool CanFallDown(IGameField field) => _gameBlock.Left.CanFallDown(field) && _gameBlock.Right.CanFallDown(field);
private bool IsGameFinished(IGameField gameField) { int rows = gameField.Rows; int columns = gameField.Columns; for (int row = 0; row < rows; row++) { for (int column = 0; column < columns; column++) { if (gameField[row, column].Symbol != GameConstants.PopedBalloonSymbol) { return false; } } } return true; }
public abstract bool CanTurn(IGameField field);
public void AcceptField(IGameField field) { _field = field; }
public abstract bool CanMove(GameSide side, IGameField field);
private char CountMines(IGameField field, int row, int column) { int counter = 0; int rows = field.Board.GetLength(0); int columns = field.Board.GetLength(1); if (row - 1 >= 0) { if (field.Board[row - 1, column] == '*') { counter++; } } if (row + 1 < rows) { if (field.Board[row + 1, column] == '*') { counter++; } } if (column - 1 >= 0) { if (field.Board[row, column - 1] == '*') { counter++; } } if (column + 1 < columns) { if (field.Board[row, column + 1] == '*') { counter++; } } if ((row - 1 >= 0) && (column - 1 >= 0)) { if (field.Board[row - 1, column - 1] == '*') { counter++; } } if ((row - 1 >= 0) && (column + 1 < columns)) { if (field.Board[row - 1, column + 1] == '*') { counter++; } } if ((row + 1 < rows) && (column - 1 >= 0)) { if (field.Board[row + 1, column - 1] == '*') { counter++; } } if ((row + 1 < rows) && (column + 1 < columns)) { if (field.Board[row + 1, column + 1] == '*') { counter++; } } return char.Parse(counter.ToString()); }
public SmartestPlayer(IGameField selfField) : base(selfField) { }
public void SetUp() { rules = GameRules.Default; shipsCount = rules.ShipsCount.ToDictionary(x => x.Key, x => x.Value); field = FromLines(rules, SampleField); }
protected Level(IGameField gameField, IWriter writer, IReader reader) { this.GameField = gameField; this.Writer = writer; this.Reader = reader; }
public FirstLevel(IGameField gameField, IWriter writer, IReader reader) : base(gameField, writer, reader) { }
public void MovePiece(ref IGameField currentField, ref IGameField fieldToMove) { // TODO Implement movement }
/// <summary> /// Gets whether the given cell is considered 'alive'. /// </summary> /// <param name="x">The position of the cell on the x-axis.</param> /// <param name="y">The position of the cell on the y-axis.</param> /// <param name="gameField">The IGameField to pull the data from.</param> /// <returns> /// Returns 0 if the index is out of valid range or the cell is 'dead'; /// returns 1 if the cell is 'alive'. /// </returns> private int GetCellState( int x, int y, IGameField gameField ) { if( this.hasSolidWalls ) { if( x < 0 || x >= gameField.Width ) return 0; if( y < 0 || y >= gameField.Height ) return 0; return gameField.GetCellStateStrict( x, y ) ? 1 : 0; } else { return gameField.GetCellState( x, y ) ? 1 : 0; } }
private void PrintMatrix(IGameField field) { int rows = field.Rows; int columns = field.Columns; for (int row = 0; row < rows; row++) { // Prints rows index this.consoleWriter.Write(FieldLeftBorderSymbol, row + 1); for (int column = 0; column < columns; column++) { if (ObjectValidator.IsGameObjectNull(field[row, column])) { throw new ArgumentNullException(FieldCellNullErrorMessage); } string symbol = field[row, column].Symbol; BalloonsColors symbolColor = field[row, column].Color; ConsoleHelper.ChangeForegroundColorDependingOnSymbol(symbolColor); this.consoleWriter.Write(field[row, column].Symbol + " "); } Console.ForegroundColor = ConsoleColor.Gray; this.consoleWriter.Write(FieldRigthBorderSymbol); Console.WriteLine(); } }
private void ReorderBallons(ReorderBalloonsStrategy reorderStrategy, IGameField gameField) { reorderStrategy.ReorderBalloons(gameField); }
/// <summary> /// Method which knows how to render on console game field matrix. /// </summary> /// <param name="field">Field to render.</param> public void RenderGameField(IGameField field) { if (ObjectValidator.IsGameObjectNull(field)) { throw new ArgumentNullException(FieldNullErrorMessage); } int columns = field.Columns; // Prints columns index this.consoleWriter.Write(Indent); for (int i = 0; i < columns; i++) { this.consoleWriter.Write(" {0}", i + 1); } Console.WriteLine(); this.PrintBorder(columns); this.PrintMatrix(field); this.PrintBorder(columns); }
public bool CheckPossibilityToKill(Coord coord, IGameField field) { return(CheckerState.CheckPossibilityToKill(CurrentCoord, coord, field)); }
public override bool CanTurn(IGameField field) { return(_gameBlock.Right.Row > 0 && field[_gameBlock.Right.Row - 1, _gameBlock.Right.Column + 1].Type == GameCellType.None); }
public Game(IGameConfiguration gameConfiguration) { gameField = new GameField(gameConfiguration.Rows, gameConfiguration.Columns, gameConfiguration.BombsCount); bombsCount = gameConfiguration.BombsCount; }
public RestoreCommand(IFieldMemoryManager fieldMemorizerManager, IGameField field) { this.field = field; this.fieldMemorizerManager = fieldMemorizerManager; this.Name = "restore"; }
public ICommand ProcessCommand( string commandString, IRenderer renderer, IGameField field, IFieldMemoryManager fieldMemoryManager, IBalloonsFactory balloonsFactory) { var commandParts = this.SplitCommandString(commandString); string commandName = commandParts[0]; int rowPosition = -1; int colPosition = -1; if (commandParts.Length == 3) { bool rowAndColumnPopulated = !(string.IsNullOrWhiteSpace(commandParts[1]) && string.IsNullOrWhiteSpace(commandParts[2])); bool rowAsInteger = int.TryParse(commandParts[1], out rowPosition); bool columnAsInteger = int.TryParse(commandParts[2], out colPosition); if (rowAndColumnPopulated && rowAsInteger && columnAsInteger) { rowPosition--; colPosition--; } else { rowPosition = InvalidRowAndColumnPosition; colPosition = InvalidRowAndColumnPosition; } } switch (commandName) { case "pop": { return new PopBalloonsCommand(balloonsFactory, field, rowPosition, colPosition); } case "top": { return new TopScoresCommand(renderer); } case "save": { return new SaveCommand(fieldMemoryManager, field); } case "restore": { return new RestoreCommand(fieldMemoryManager, field); } case "help": { return new HelpCommand(renderer); } case "exit": { return new ExitCommand(renderer); } default: { throw new InvalidOperationException("Invalid command request!"); } } }
public void StartTurn(IGameField field) => turnController.MakeTurn(pos => OnMadeTurn?.Invoke(this, pos));
/// <summary> /// Adds the given ObjectTemplate to the given IGameField. /// </summary> /// <param name="template"> /// The template to add. /// </param> /// <param name="offsetX"> /// The offset to apply on the x-axis. /// </param> /// <param name="offsetY"> /// The offset to apply on the y-axis. /// </param> /// <param name="gameField"> /// The IGameField to fill with data. /// </param> public void AddTemplate( ObjectTemplate template, int offsetX, int offsetY, IGameField gameField ) { this.offsetX = offsetX; this.offsetY = offsetY; this.gameField = gameField; switch( template ) { case ObjectTemplate.Glider: this.AddGlider(); break; case ObjectTemplate.Chaos: this.AddChaos(); break; case ObjectTemplate.Laser0: this.AddLaser0(); break; case ObjectTemplate.Laser2: this.AddLaser2(); break; case ObjectTemplate.Horseshoe: this.AddHorseshoe(); break; case ObjectTemplate.Flower: this.AddFlower(); break; case ObjectTemplate.Claphand: this.AddToad(); break; case ObjectTemplate.Acorn: this.AddAcorn(); break; case ObjectTemplate.Octagon: this.AddOctagon(); break; case ObjectTemplate.Pentadecathlon: this.AddPentadecathlon(); break; case ObjectTemplate.Bugface: this.AddBugface(); break; case ObjectTemplate.Tumbler: this.AddTumbler(); break; case ObjectTemplate.Diehard: this.AddDiehard(); break; case ObjectTemplate.Pulsar: this.AddPulsar(); break; case ObjectTemplate.QueenBeeShuttle: this.AddQueenBeeShuttle(); break; case ObjectTemplate.SpaceshipLightweight: this.AddLightweightSpaceship(); break; default: throw new NotImplementedException( template.ToString() ); } }
public async Task <ICommand> MakeStep(IGameField grid) { return(await Task <ICommand> .Run <ICommand>(new Func <ICommand>(MakeTurn))); }
/// <summary> /// Abstract interface of a method for reordering matrix. /// </summary> /// <param name="gameField">The field which will be reordered.</param> public abstract void ReorderBalloons(IGameField gameField);
public ApplicationControllerTestable() { _gameField = new GameField(); }
public void Launch(Vector3 direction, bool recochet, IGameField gameField) { this.direction = direction; this.recochet = recochet; this.gameField = gameField; }
public ApplicationControllerTestable(IGameField gameField) { _gameField = gameField; }
private void ChancheTurns(IGameField field, IGameField mines, int row, int column) { char numberOfMines = CountMines(mines, row, column); mines.Board[row, column] = numberOfMines; field.Board[row, column] = numberOfMines; }
public SecondLevel(IGameField gameField, IWriter writer, IReader reader) : base(gameField, writer, reader) { }
public void Run() { this.isStarted = true; IExecutable command = null; while (this.isStarted) { if (flag) { this.Writer.WriteLine( "Lets play “Mini4KI”. Try your luck to find all cells wuthout mines." + " Command 'top' showes the scores, 'restart' starts new game, 'exit' quits the game!"); MakeBorders(gameField); this.flag = false; } this.Writer.Write("Enter row[0...4] and column[0...9], separated by space: "); this.input = Console.ReadLine().Trim(); string line = this.Reader.ReadNextLine().Trim(); // string[] inputArgs = line.Split(' '); // // command = this.commandManager.ManageCommand(line); // // try // { // command.OnExecuting += (sender, args) => // { // this.isStarted = !args.Stopped; // }; // // command.Execute(); // } // catch (Exception e) // { // this.Writer.WriteLine(e.Message); // } if (this.input.Length >= 3) { int row = 0; int column = 0; if (int.TryParse(this.input[0].ToString(), out row) && int.TryParse(this.input[2].ToString(), out column) && row <= this.gameField.Board.GetLength(0) && column <= this.gameField.Board.GetLength(1)) { this.input = "turn"; } } switch (this.input) { case "top": ShowScores(this.players); break; case "restart": this.gameField = FieldsFactory.Create(); this.mines = InsertMines(); MakeBorders(this.gameField); this.grum = false; this.flag = false; break; case "exit": this.Writer.WriteLine("Bye, bye, bye!"); break; case "turn": if (this.mines.Board[row, column] != '*') { if (this.mines.Board[row, column] == '-') { ChancheTurns(this.gameField, this.mines, row, column); this.counter++; } if (maks == this.counter) { this.flag2 = true; } else { MakeBorders(gameField); } } else { grum = true; } break; default: this.Writer.WriteLine("\nError! Invalid input\n"); break; } if (grum) { MakeBorders(mines); this.Writer.Write(string.Format("\nHrrrrrr! You have died with {0} scores. " + "Enter nickName: ", counter)); string nickName = this.Reader.ReadNextLine(); Player player = new Player(nickName, counter); if (players.Count < 5) { players.Add(player); } else { for (int i = 0; i < players.Count; i++) { if (players[i].Scores < player.Scores) { players.Insert(i, player); players.RemoveAt(players.Count - 1); break; } } } players.Sort((Player firstPlayer, Player secondPlayer) => secondPlayer.Name.CompareTo(firstPlayer.Name)); players.Sort((Player firstPlayer, Player secondPlayer) => secondPlayer.Scores.CompareTo(firstPlayer.Scores)); ShowScores(players); gameField = FieldsFactory.Create(); mines = InsertMines(); counter = 0; grum = false; flag = true; } if (flag2) { this.Writer.WriteLine("\nBRAVOOOS! Otvri 35 kletki bez kapka kryv."); MakeBorders(mines); this.Writer.WriteLine("Enter your name: "); string name = this.Reader.ReadNextLine(); Player player = new Player(name, counter); players.Add(player); ShowScores(players); gameField = FieldsFactory.Create(); mines = InsertMines(); counter = 0; flag2 = false; flag = true; } this.Writer.WriteLine("Made in Bulgaria - Uauahahahahaha!"); this.Writer.WriteLine("AREEEEEEeeeeeee."); Console.Read(); } }
public virtual IViewModel BuildMainViewModel(IGameField gameField, IGameScoreManager gameScoreManager, INewViewFactory newViewFactory) => new MainViewModel(gameField, gameScoreManager, newViewFactory);