private List <ChessBoardPosition> GetValidMovePositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition) { var validPositions = new List <ChessBoardPosition>(); for (int radius = 1; radius < MovementPoint + 1; radius++) { ChessBoardPosition upLeftPosition = chessBoard.CalculatePosition(currentPosition, radius, radius); ChessBoardPosition upRight = chessBoard.CalculatePosition(currentPosition, radius, -radius); ChessBoardPosition downLeftPosition = chessBoard.CalculatePosition(currentPosition, -radius, radius); ChessBoardPosition downRightPosition = chessBoard.CalculatePosition(currentPosition, -radius, -radius); validPositions.Add(upLeftPosition); validPositions.Add(upRight); validPositions.Add(downLeftPosition); validPositions.Add(downRightPosition); ChessBoardPosition upPosition = chessBoard.CalculatePosition(currentPosition, radius, 0); ChessBoardPosition downPosition = chessBoard.CalculatePosition(currentPosition, -radius, 0); ChessBoardPosition leftPosition = chessBoard.CalculatePosition(currentPosition, 0, radius); ChessBoardPosition rightPosition = chessBoard.CalculatePosition(currentPosition, 0, -radius); validPositions.Add(upPosition); validPositions.Add(downPosition); validPositions.Add(leftPosition); validPositions.Add(rightPosition); } return(validPositions); }
private List <ChessBoardPosition> GetValidMovePositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition) { var validPositions = new List <ChessBoardPosition>(); ChessBoardPosition upLeftPosition = chessBoard.CalculatePosition(currentPosition, 2, 1); ChessBoardPosition upRightPosition = chessBoard.CalculatePosition(currentPosition, 2, -1); ChessBoardPosition downLeftPosition = chessBoard.CalculatePosition(currentPosition, -2, 1); ChessBoardPosition downRightPosition = chessBoard.CalculatePosition(currentPosition, -2, -1); ChessBoardPosition leftUpPosition = chessBoard.CalculatePosition(currentPosition, 1, 2); ChessBoardPosition leftDownPosition = chessBoard.CalculatePosition(currentPosition, -1, 2); ChessBoardPosition rightUpPosition = chessBoard.CalculatePosition(currentPosition, 1, -2); ChessBoardPosition rightDownPosition = chessBoard.CalculatePosition(currentPosition, -1, -2); validPositions.Add(upLeftPosition); validPositions.Add(upRightPosition); validPositions.Add(downLeftPosition); validPositions.Add(downRightPosition); validPositions.Add(leftUpPosition); validPositions.Add(leftDownPosition); validPositions.Add(rightUpPosition); validPositions.Add(rightDownPosition); return(validPositions); }
public override void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition) { var validPositions = GetValidAttackPositions(chessBoard, currentPosition); validPositions.RemoveAll(p => p == null); if (targetPosition == null) { throw new Exception("The specified cell is outside the chess board field."); } if (validPositions.Any(p => p.CurrentRow == targetPosition.CurrentRow && p.CurrentColumn == targetPosition.CurrentColumn)) { ChessBoardCell cell = chessBoard.GetCell(targetPosition); if (cell.IsOccupied && cell.Entity != null) { cell.Entity.HitPoints = cell.Entity.HitPoints - AttackPower; Console.WriteLine($"Hit on enemy {cell.Entity.Name} for {AttackPower} damage!"); if (cell.Entity.HitPoints < 1) { Console.WriteLine($"Enemy {cell.Entity.Name} is destroyed!"); chessBoard.EmptyCell(targetPosition); } Console.ReadLine(); } } else { throw new Exception("Invalid attack position. Specified cell is not in the attack range."); } }
private void SelectEntityDuringHumanTurn(string line) { ChessBoardPosition chessBoardPosition = _chessBoard.ParseChessBoardCellPosition(line); if (chessBoardPosition == null) { Console.WriteLine("Invalid cell."); return; } ChessBoardCell cell = _chessBoard.GetCell(chessBoardPosition); if (cell == null) { Console.WriteLine($"Specified cell {line} is empty."); } else if (cell.IsOccupied) { if (_playedEntityIDs.Contains(cell.Entity.ID)) { Console.WriteLine($"You've already played with the piece on {line}."); } else { _selectedEntity = cell.Entity; } } }
public override void Move(ChessBoard.ChessBoard chessBoard, ChessBoardPosition oldPosition, ChessBoardPosition newPosition) { List <PlayerPiece> playerPieces = chessBoard.GetPlayerPiecesBasedOnControlType(EntityControlType.Human); var validMoves = new List <KeyValuePair <int, List <Point> > >(); foreach (PlayerPiece playerPiece in playerPieces) { bool[,] chessBoardGrid = chessBoard.GetPathfinderGrid(); chessBoardGrid[oldPosition.CurrentRow, oldPosition.CurrentColumn] = true; chessBoardGrid[playerPiece.CurrentPosition.CurrentRow, playerPiece.CurrentPosition.CurrentColumn] = true; Point startLocation = new Point(oldPosition.CurrentRow, oldPosition.CurrentColumn); Point endLocation = new Point(playerPiece.CurrentPosition.CurrentRow, playerPiece.CurrentPosition.CurrentColumn); SearchParameters sp = new SearchParameters(startLocation, endLocation, chessBoardGrid); PathFinder pathfinder = new PathFinder(sp); List <Point> nodes = pathfinder.FindPath(); validMoves.Add(new KeyValuePair <int, List <Point> >(nodes.Count, nodes)); } var paths = new List <int>(); foreach (KeyValuePair <int, List <Point> > pair in validMoves) { paths.Add(pair.Key); } paths.Sort(); KeyValuePair <int, List <Point> > nextPosition = new KeyValuePair <int, List <Point> >(0, null); if (paths.Count > 0) { nextPosition = validMoves.Find(m => m.Key == paths[0]); } if (paths.Count > 0 && nextPosition.Key != 0) { newPosition = new ChessBoardPosition { CurrentColumn = nextPosition.Value[0].Y, CurrentRow = nextPosition.Value[0].X, }; ChessBoardCell newCell = chessBoard.GetCell(newPosition); if (newCell.IsOccupied) { return; } else { ChessBoardCell cell = chessBoard.GetCell(oldPosition); chessBoard.SetCell(newPosition, cell); chessBoard.EmptyCell(oldPosition); } } }
private List <ChessBoardPosition> GetValidAttackPositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition) { var validPositions = new List <ChessBoardPosition>(); ChessBoardPosition upPosition = chessBoard.CalculatePosition(currentPosition, 1, 0, true); ChessBoardPosition downPosition = chessBoard.CalculatePosition(currentPosition, -1, 0, true); ChessBoardPosition leftPosition = chessBoard.CalculatePosition(currentPosition, 0, 1, true); ChessBoardPosition rightPosition = chessBoard.CalculatePosition(currentPosition, 0, -1, true); validPositions.Add(upPosition); validPositions.Add(downPosition); validPositions.Add(leftPosition); validPositions.Add(rightPosition); return(validPositions); }
private List <ChessBoardPosition> GetValidMovePositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition) { var validPositions = new List <ChessBoardPosition>(); ChessBoardPosition upPosition = chessBoard.CalculatePosition(currentPosition, MovementPoint, 0); ChessBoardPosition downPosition = chessBoard.CalculatePosition(currentPosition, -MovementPoint, 0); ChessBoardPosition leftPosition = chessBoard.CalculatePosition(currentPosition, 0, MovementPoint); ChessBoardPosition rightPosition = chessBoard.CalculatePosition(currentPosition, 0, -MovementPoint); validPositions.Add(upPosition); validPositions.Add(downPosition); validPositions.Add(leftPosition); validPositions.Add(rightPosition); return(validPositions); }
public override void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition) { var validAttackPosition = new List <ChessBoardPosition>(); ChessBoardPosition upLeftPosition = chessBoard.CalculatePosition(currentPosition, 1, 1, true); ChessBoardPosition upRight = chessBoard.CalculatePosition(currentPosition, 1, -1, true); ChessBoardPosition downLeftPosition = chessBoard.CalculatePosition(currentPosition, -1, 1, true); ChessBoardPosition downRightPosition = chessBoard.CalculatePosition(currentPosition, -1, -1, true); ChessBoardPosition upPosition = chessBoard.CalculatePosition(currentPosition, 1, 0, true); ChessBoardPosition downPosition = chessBoard.CalculatePosition(currentPosition, -1, 0, true); ChessBoardPosition leftPosition = chessBoard.CalculatePosition(currentPosition, 0, 1, true); ChessBoardPosition rightPosition = chessBoard.CalculatePosition(currentPosition, 0, -1, true); validAttackPosition.Add(upLeftPosition); validAttackPosition.Add(upRight); validAttackPosition.Add(downLeftPosition); validAttackPosition.Add(downRightPosition); validAttackPosition.Add(upPosition); validAttackPosition.Add(downPosition); validAttackPosition.Add(leftPosition); validAttackPosition.Add(rightPosition); validAttackPosition.RemoveAll(p => p == null); foreach (ChessBoardPosition position in validAttackPosition) { ChessBoardCell target = chessBoard.GetCell(position); if (target.IsOccupied && target.Entity != null && target.Entity.ControlType == EntityControlType.Human) { target.Entity.HitPoints = target.Entity.HitPoints - AttackPower; Console.WriteLine($"Hit on enemy {target.Entity.Name} for {AttackPower} damage!"); if (target.Entity.HitPoints < 1) { Console.WriteLine($"Enemy {target.Entity.Name} is destroyed!"); chessBoard.EmptyCell(position); } Console.ReadLine(); } } }
private List <ChessBoardPosition> GetValidAttackPositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition) { var validPositions = new List <ChessBoardPosition>(); for (int orthogonal = 1; orthogonal < chessBoard.Rows; orthogonal++) { ChessBoardPosition upPosition = chessBoard.CalculatePosition(currentPosition, orthogonal, 0, true); ChessBoardPosition downPosition = chessBoard.CalculatePosition(currentPosition, -orthogonal, 0, true); ChessBoardPosition leftPosition = chessBoard.CalculatePosition(currentPosition, 0, orthogonal, true); ChessBoardPosition rightPosition = chessBoard.CalculatePosition(currentPosition, 0, -orthogonal, true); validPositions.Add(upPosition); validPositions.Add(downPosition); validPositions.Add(leftPosition); validPositions.Add(rightPosition); } return(validPositions); }
private List <ChessBoardPosition> GetValidAttackPositions(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition) { var validPositions = new List <ChessBoardPosition>(); for (int diagonalCorner = 1; diagonalCorner < chessBoard.Rows; diagonalCorner++) { ChessBoardPosition upLeftPosition = chessBoard.CalculatePosition(currentPosition, diagonalCorner, diagonalCorner, true); ChessBoardPosition upRight = chessBoard.CalculatePosition(currentPosition, diagonalCorner, -diagonalCorner, true); ChessBoardPosition downLeftPosition = chessBoard.CalculatePosition(currentPosition, -diagonalCorner, diagonalCorner, true); ChessBoardPosition downRightPosition = chessBoard.CalculatePosition(currentPosition, -diagonalCorner, -diagonalCorner, true); validPositions.Add(upLeftPosition); validPositions.Add(upRight); validPositions.Add(downLeftPosition); validPositions.Add(downRightPosition); } return(validPositions); }
private void DreadnoughtsMoveAndAttack() { List <PlayerPiece> dreadnoughts = _chessBoard.GetPlayerPiecesBasedOnEntityType(EntityType.Dreadnought); if (dreadnoughts.Count > 1) { dreadnoughts.Shuffle(); } foreach (PlayerPiece dreadnought in dreadnoughts) { Entity entity = _chessBoard.GetEntity(dreadnought); entity.Move(_chessBoard, dreadnought.CurrentPosition, null); UpdateScreen(); Thread.Sleep(450); ChessBoardPosition newEntityPosition = _chessBoard.GetEntityPosition(dreadnought.EntityID); entity.Attack(_chessBoard, newEntityPosition, null); } }
public override void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition) { var validPositions = GetValidAttackPositions(chessBoard, currentPosition); validPositions.RemoveAll(p => p == null); var validTargets = new List <ChessBoardPosition>(); foreach (ChessBoardPosition validPosition in validPositions) { ChessBoardCell cell = chessBoard.GetCell(validPosition); if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human) { validTargets.Add(validPosition); } } if (validTargets.Count > 0) { validTargets.Shuffle(); ChessBoardCell target = chessBoard.GetCell(validTargets[0]); if (target.IsOccupied && target.Entity != null) { target.Entity.HitPoints = target.Entity.HitPoints - AttackPower; Console.WriteLine($"Hit on enemy {target.Entity.Name} for {AttackPower} damage!"); if (target.Entity.HitPoints < 1) { Console.WriteLine($"Enemy {target.Entity.Name} is destroyed!"); chessBoard.EmptyCell(validTargets[0]); } Console.ReadLine(); } } }
public override void Move(ChessBoard.ChessBoard chessBoard, ChessBoardPosition oldPosition, ChessBoardPosition newPosition) { var validPositions = GetValidMovePositions(chessBoard, oldPosition); validPositions.RemoveAll(p => p == null); if (newPosition == null) { throw new Exception("The specified cell is outside the chess board field."); } if (validPositions.Any(p => p.CurrentRow == newPosition.CurrentRow && p.CurrentColumn == newPosition.CurrentColumn)) { ChessBoardCell cell = chessBoard.GetCell(oldPosition); chessBoard.SetCell(newPosition, cell); chessBoard.EmptyCell(oldPosition); } else { throw new Exception("Invalid move. Specified cell is not a valid move."); } }
public override void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition) { var validPositions = GetValidAttackPositions(chessBoard, currentPosition); validPositions.RemoveAll(p => p == null); foreach (ChessBoardPosition position in validPositions) { ChessBoardCell cell = chessBoard.GetCell(position); if (cell.IsOccupied && cell.Entity != null) { cell.Entity.HitPoints = cell.Entity.HitPoints - AttackPower; Console.WriteLine($"Hit on enemy {cell.Entity.Name} for {AttackPower} damage!"); if (cell.Entity.HitPoints < 1) { Console.WriteLine($"Enemy {cell.Entity.Name} is destroyed!"); chessBoard.EmptyCell(position); } Console.ReadLine(); } } }
public override void Move(ChessBoard.ChessBoard chessBoard, ChessBoardPosition oldPosition, ChessBoardPosition newPosition) { if ((oldPosition.CurrentRow + 1) < 8) { newPosition = new ChessBoardPosition { CurrentColumn = oldPosition.CurrentColumn, CurrentRow = oldPosition.CurrentRow + 1, }; ChessBoardCell newCell = chessBoard.GetCell(newPosition); if (newCell.IsOccupied) { return; } else { ChessBoardCell cell = chessBoard.GetCell(oldPosition); chessBoard.SetCell(newPosition, cell); chessBoard.EmptyCell(oldPosition); } } }
public override void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition) { //This unit does not attack. }
public virtual void Attack(ChessBoard.ChessBoard chessBoard, ChessBoardPosition currentPosition, ChessBoardPosition targetPosition) { throw new NotImplementedException(); }
public virtual void Move(ChessBoard.ChessBoard chessBoard, ChessBoardPosition oldPosition, ChessBoardPosition newPosition) { throw new NotImplementedException(); }
//下面是AI算法 public bool Algrothm() { ChessBoardPosition first = new ChessBoardPosition(); //第一次分析的当前棋位 ChessBoardPosition second = new ChessBoardPosition(); //第二次分析的当前棋位 Tree[] tree = new Tree[9]; //分析树 int node; //分析树的当前节点下标 int[,] secondBoard = new int[3, 3]; //用于第二次分析的棋盘 bool win; //第一次分析的结果,赢的标记 CopyChessBoard(); node = 0; win = false; if (button [4].interactable == false) { //第一次分析,寻找可用的棋位 for (first.line = 0; first.line < 3; first.line++) { for (first.list = 0; first.list < 3; first.list++) { if (chessBoard [first.line, first.list] == 0) { //把当前棋位入树,记录当前棋位 tree [node].position.line = first.line; tree [node].position.list = first.list; tree [node].weight = 0; //初始化权重 tree [node].chessBoard = new int[3, 3] { { 0, 0, 0 }, { 0, 0, 0 }, { 0, 0, 0 } }; //初始化第一次分析的棋盘 Array.Copy(chessBoard, tree [node].chessBoard, chessBoard.Length); //拷贝当前棋盘状况 tree [node].chessBoard [first.line, first.list] = 1; //尝试下棋,后面分析这一步的情况 if (IsWins(tree [node].chessBoard, 1) == 1) { //已找到最好情况,直接下棋 buttonList [first.line * 3 + first.list].text = playerSide; button [first.line * 3 + first.list].interactable = false; win = true; break; } //如果赢了就不需要再继续进行计算了,因为没有比这更好的情况了 //第二次分析,寻找可用的棋位 for (second.line = 0; second.line < 3; second.line++) { for (second.list = 0; second.list < 3; second.list++) { if (tree [node].chessBoard [second.line, second.list] == 0) { Array.Copy(tree [node].chessBoard, secondBoard, tree [node].chessBoard.Length); //拷贝第一次分析得到的棋盘到第二次分析的棋盘 secondBoard [second.line, second.list] = 2; //模拟人下棋,后面分析情况 tree [node].weight -= IsWins(secondBoard, 2); //如果人赢,则不利,因此要用减号 } } } node++; //分析树的节点下标+1 } } tree [node].weight = 15; //树尾的标记 if (win == true) { break; //找到最优解了,无需再分析 } } if (win == false) { //开始寻找最优解 node = 0; //设好情况为第一个节点 for (int i = 0; tree [i].weight < 15; i++) { if (tree [node].weight < tree [i].weight) { node = i; } else if (tree [node].weight <= tree [i].weight && ((tree [i].position.line * 3 + tree [i].position.list) == 0 || (tree [i].position.line * 3 + tree [i].position.list) == 2 || (tree [i].position.line * 3 + tree [i].position.list) == 6 || (tree [i].position.line * 3 + tree [i].position.list) == 8)) { node = i; } } // Debug.Log ((tree [node].position.line * 3 + tree [node].position.list)); // Debug.Log (tree [node].position.line); // Debug.Log (tree [node].position.list); buttonList [tree [node].position.line * 3 + tree [node].position.list].text = playerSide; //把棋放到最优解的位置 button [tree [node].position.line * 3 + tree [node].position.list].interactable = false; return(false); } else { return(true); } } else { //中间必须要放棋子 buttonList [4].text = playerSide; button [4].interactable = false; return(false); } }
public override void Move(ChessBoard.ChessBoard chessBoard, ChessBoardPosition oldPosition, ChessBoardPosition newPosition) { List <PlayerPiece> playerPieces = chessBoard.GetPlayerPiecesBasedOnControlType(EntityControlType.Human); CommandUnitMoveState moveState = CommandUnitMoveState.StayStill; var possibleAttacks = new List <KeyValuePair <int, List <Point> > >(); foreach (PlayerPiece playerPiece in playerPieces) { bool[,] chessBoardGrid = chessBoard.GetPathfinderGrid(); chessBoardGrid[oldPosition.CurrentRow, oldPosition.CurrentColumn] = true; chessBoardGrid[playerPiece.CurrentPosition.CurrentRow, playerPiece.CurrentPosition.CurrentColumn] = true; Point startLocation = new Point(oldPosition.CurrentRow, oldPosition.CurrentColumn); Point endLocation = new Point(playerPiece.CurrentPosition.CurrentRow, playerPiece.CurrentPosition.CurrentColumn); SearchParameters sp = new SearchParameters(startLocation, endLocation, chessBoardGrid); PathFinder pathfinder = new PathFinder(sp); List <Point> nodes = pathfinder.FindPath(); possibleAttacks.Add(new KeyValuePair <int, List <Point> >(nodes.Count, nodes)); } var paths = new List <int>(); foreach (KeyValuePair <int, List <Point> > pair in possibleAttacks) { paths.Add(pair.Key); } paths.Sort(); KeyValuePair <int, List <Point> > nearestEnemy = new KeyValuePair <int, List <Point> >(0, null); if (paths.Count > 0) { nearestEnemy = possibleAttacks.Find(m => m.Key == paths[0]); } if (paths.Count > 0 && nearestEnemy.Key != 0) { if (nearestEnemy.Key == 1 || nearestEnemy.Key == 2) { if (nearestEnemy.Value[nearestEnemy.Value.Count - 1].X >= oldPosition.CurrentRow) { moveState = CommandUnitMoveState.MoveLeft; } else if ((nearestEnemy.Value[nearestEnemy.Value.Count - 1].X <= oldPosition.CurrentRow)) { moveState = CommandUnitMoveState.MoveRight; } } else { bool safeUpLeft = false; for (int radius = 0; radius < chessBoard.Columns; radius++) { ChessBoardPosition upLeftPosition = chessBoard.CalculatePosition(oldPosition, radius, radius, true); if (upLeftPosition != null) { ChessBoardCell cell = chessBoard.GetCell(upLeftPosition); if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human) { safeUpLeft = false; } if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai) { safeUpLeft = true; } } } bool safeUpRight = false; for (int radius = 0; radius < chessBoard.Columns; radius++) { ChessBoardPosition upRightPosition = chessBoard.CalculatePosition(oldPosition, radius, -radius, true); if (upRightPosition != null) { ChessBoardCell cell = chessBoard.GetCell(upRightPosition); if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human) { safeUpRight = false; } if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai) { safeUpRight = true; } } } bool safeDownLeft = false; for (int radius = 0; radius < chessBoard.Columns; radius++) { ChessBoardPosition downLeftPosition = chessBoard.CalculatePosition(oldPosition, -radius, radius, true); if (downLeftPosition != null) { ChessBoardCell cell = chessBoard.GetCell(downLeftPosition); if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human) { safeDownLeft = false; } if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai) { safeDownLeft = true; } } } bool safeDownRight = false; for (int radius = 0; radius < chessBoard.Columns; radius++) { ChessBoardPosition downRightPosition = chessBoard.CalculatePosition(oldPosition, -radius, -radius, true); if (downRightPosition != null) { ChessBoardCell cell = chessBoard.GetCell(downRightPosition); if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human) { safeDownRight = false; } if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai) { safeDownRight = true; } } } bool safeUp = false; for (int radius = 0; radius < chessBoard.Columns; radius++) { ChessBoardPosition upPosition = chessBoard.CalculatePosition(oldPosition, radius, 0, true); if (upPosition != null) { ChessBoardCell cell = chessBoard.GetCell(upPosition); if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human) { safeUp = false; } if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai) { safeUp = true; } } } bool safeDown = false; for (int radius = 0; radius < chessBoard.Columns; radius++) { ChessBoardPosition downPosition = chessBoard.CalculatePosition(oldPosition, -radius, 0, true); if (downPosition != null) { ChessBoardCell cell = chessBoard.GetCell(downPosition); if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Human) { safeDown = false; } if (cell.IsOccupied && cell.Entity.ControlType == EntityControlType.Ai) { safeDown = true; } } } if (safeUpLeft && safeUpRight && safeDownLeft && safeDownRight) { moveState = CommandUnitMoveState.StayStill; } if (!safeUpLeft || !safeDownLeft || !safeUp) { moveState = CommandUnitMoveState.MoveRight; } if (!safeUpRight || !safeDownRight || !safeDown) { moveState = CommandUnitMoveState.MoveLeft; } } } if (moveState == CommandUnitMoveState.MoveLeft) { newPosition = new ChessBoardPosition { CurrentColumn = oldPosition.CurrentColumn - 1, CurrentRow = oldPosition.CurrentRow, }; } else if (moveState == CommandUnitMoveState.MoveRight) { newPosition = new ChessBoardPosition { CurrentColumn = oldPosition.CurrentColumn + 1, CurrentRow = oldPosition.CurrentRow, }; } else if (moveState == CommandUnitMoveState.StayStill) { return; } if (newPosition.CurrentColumn >= 0 && newPosition.CurrentRow >= 0) { ChessBoardCell newCell = chessBoard.GetCell(newPosition); if (newCell.IsOccupied) { return; } else { ChessBoardCell cell = chessBoard.GetCell(oldPosition); chessBoard.SetCell(newPosition, cell); chessBoard.EmptyCell(oldPosition); } } }
private void HumanPlay() { while (_currentGameState == GameState.PlayerTurn) { if (_playedEntityIDs.Count == _humanPlayerPieces.Count) { Console.WriteLine("You've played with all your pieces. Ending turn..."); Console.ReadLine(); EndTurn(); _currentGameState = GameState.AiTurn; break; } #region Play with selected piece if (_selectedEntity != null) { Console.ForegroundColor = ConsoleColor.Cyan; switch (_selectedEntity.Type) { case EntityType.Grunt: Console.WriteLine("Grunt can move 1 space orthogonally. Attacks diagonally at any range."); break; case EntityType.Jumpship: Console.WriteLine(@"Jumpship moves like the knight in chess. Attack all 4 spaces orthogonally adjacent. For attacking, specify Jumpship's current position."); break; case EntityType.Tank: Console.WriteLine("Tank moves like the Queen in chess, up to 3 spaces. Attacks orthogonally at any range"); break; } Console.ResetColor(); Console.Write("Select new cell to move (<column><row>) or deselect (deselect) the current piece: "); string inputLine = Console.ReadLine(); if (inputLine == "deselect") { _selectedEntity = null; break; } else if (inputLine.Length == 2) { ChessBoardPosition newChessBoardPosition = _chessBoard.ParseChessBoardCellPosition(inputLine); ChessBoardPosition oldChessBoardPosition = (_humanPlayerPieces.First(p => p.EntityID == _selectedEntity.ID)).CurrentPosition; try { _selectedEntity.Move(_chessBoard, oldChessBoardPosition, newChessBoardPosition); _humanPlayerPieces = _chessBoard.GetPlayerPiecesBasedOnControlType(EntityControlType.Human); UpdateScreen(); string inputAttack = string.Empty; while (inputAttack == string.Empty) { Console.Write("Select cell (<column><row>) to attack or skip (skip) attack: "); inputAttack = Console.ReadLine(); if (inputAttack.Length == 2) { ChessBoardPosition targetPosition = _chessBoard.ParseChessBoardCellPosition(inputAttack); if (targetPosition == null) { Console.WriteLine("Invalid cell."); inputAttack = string.Empty; } else { try { ChessBoardPosition currentPosition = (_humanPlayerPieces.First(p => p.EntityID == _selectedEntity.ID)).CurrentPosition; _selectedEntity.Attack(_chessBoard, currentPosition, targetPosition); _aiPlayerPieces = _chessBoard.GetPlayerPiecesBasedOnControlType(EntityControlType.Ai); } catch (Exception ex) { Console.WriteLine(ex.Message); inputAttack = string.Empty; } } } else if (inputAttack == "skip") { inputAttack = "skip"; } else { inputAttack = string.Empty; } } _playedEntityIDs.Add(_selectedEntity.ID); _selectedEntity = null; break; } catch (Exception ex) { Console.ForegroundColor = ConsoleColor.Red; Console.WriteLine(ex.Message); Console.ReadLine(); Console.ResetColor(); break; } } else { break; } } #endregion CheckVictoryConditions(); if (metVictoryCondition) { return; } #region Select piece or end turn Console.Write("Select player piece (<column><row>), end turn (endturn), or quit (exit): "); string line = Console.ReadLine(); if (line != string.Empty) { if (line == "endturn") { EndTurn(); _currentGameState = GameState.AiTurn; } else if (line == "exit") { _currentGameState = GameState.Quit; return; } else if (line.Length == 2) { SelectEntityDuringHumanTurn(line); } } #endregion } }