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
}
}
