public static IEnumerable<IMove> GetAllMovesFromField(GameBoard board, BoardPosition fromFieldPosition, out bool forcedOnly)
{
PlayerColor player = board[fromFieldPosition].Occupation;
List<IMove> moves = new List<IMove>();
var firstTargets = GetPossibleTargetFields(board, fromFieldPosition, out forcedOnly);
if (!forcedOnly)
{
moves.AddRange(firstTargets.Select(pos => new SimpleMove(player, fromFieldPosition, pos, board[fromFieldPosition].Piece == PieceType.King, false)));
return moves;
}
JumpTree tree = new JumpTree(fromFieldPosition, firstTargets, board);
ConstructJumpTree(ref tree);
var paths = tree.Linearize();
tree = null;
foreach (var path in paths)
{
if (path.Count == 2)
{
moves.Add(new SimpleMove(player, path[0], path[1], board[fromFieldPosition].Piece == PieceType.King, true));
}
else
{
CompoundMove move = CompoundMove.FromPositions(player, path.First(), path.Last(), board[fromFieldPosition].Piece == PieceType.King, path.GetRange(1, path.Count - 2).ToArray());
moves.Add(move);
}
}
return moves;
}
private IEnumerable<BoardPosition> GetBoardPieces(IVirtualBoard board, BoardPosition piece, MainWindow.Surround direction)
{
Func<BoardPosition, BoardPosition> dir = p =>
{
switch (direction)
{
case MainWindow.Surround.Top:
return board.TopOf(p);
case MainWindow.Surround.Right:
return board.RightOf(p);
case MainWindow.Surround.Bottom:
return board.BottomOf(p);
case MainWindow.Surround.Left:
return board.LeftOf(p);
default:
throw new ArgumentOutOfRangeException("direction");
}
};
var borderingPiece = dir(piece);
if (borderingPiece != null && borderingPiece.Piece.RootBoardPiece == piece.Piece.RootBoardPiece)
{
yield return borderingPiece;
var borderingPiece2 = dir(borderingPiece);
if (borderingPiece2 != null && borderingPiece2.Piece.RootBoardPiece == piece.Piece.RootBoardPiece)
yield return borderingPiece2;
}
}
public IMoveResults MovePawn(int rowFrom, int columnFrom, int rowTo, int columnTo) {
BreakthroughPawn pawn = core.PawnAt(rowFrom, columnFrom);
BreakthroughPawn target = core.PawnAt(rowTo, columnTo);
BreakthroughPawn killed = null;
BoardPosition from = new BoardPosition(rowFrom, columnFrom);
BoardPosition to = new BoardPosition(rowTo, columnTo);
bool gameOver = false;
Player winner = pawn.Player;
if (!ValidateMove(rowFrom, columnFrom, rowTo, columnTo)) {
return new BreakthroughMoveResults(false, killed, from, to, gameOver, winner);
}
if (target != null) {
core.RemovePawn(target.Row, target.Column);
killed = target;
}
// If the pawn reaches the end of the board the game is over.
if (rowTo == 0 || rowTo == core.Size-1) {
gameOver = true;
}
core.MovePawn(rowFrom, columnFrom, rowTo, columnTo);
// Swap the turn.
if (core.Turn == Player.white) {
core.Turn = Player.black;
}
else {
core.Turn = Player.white;
}
return new BreakthroughMoveResults(true, killed, from, to, gameOver, winner);
}
public ChessPosition( ChessPosition chessPos )
{
this.posType = chessPos.posType;
this.nRank = chessPos.nRank;
this.nPile = chessPos.nPile;
this.pos = chessPos.pos;
}
protected virtual bool MoveDownSolves( BoardPosition position )
{
var firstBottomOf = _board.BottomOf( position );
if ( firstBottomOf == null || firstBottomOf.Piece == position.Piece )
return false;
var secondBottomOf = _board.BottomOf( firstBottomOf );
var thirdBottomOf = _board.BottomOf( secondBottomOf );
var firstNewLeftOf = _board.LeftOf( firstBottomOf );
var secondNewLeftOf = _board.LeftOf( firstNewLeftOf );
var firstNewRightOf = _board.RightOf( firstBottomOf );
var secondNewRightOf = _board.RightOf( firstNewRightOf );
bool alignsBottom = ( secondBottomOf != null && thirdBottomOf != null )
&& ( position.Piece == secondBottomOf.Piece )
&& ( position.Piece == thirdBottomOf.Piece );
bool alignsLeft = ( firstNewLeftOf != null && secondNewLeftOf != null )
&& ( position.Piece == firstNewLeftOf.Piece )
&& ( position.Piece == secondNewLeftOf.Piece );
bool alignsRight = ( firstNewRightOf != null && secondNewRightOf != null )
&& ( position.Piece == firstNewRightOf.Piece )
&& ( position.Piece == secondNewRightOf.Piece );
bool alignsLeftRight = ( firstNewLeftOf != null && firstNewRightOf != null )
&& ( position.Piece == firstNewLeftOf.Piece )
&& ( position.Piece == firstNewRightOf.Piece );
return alignsBottom || alignsLeft || alignsRight || alignsLeftRight;
}
public void HandleBattle(UnitPiece attacker, BoardPosition attackerPosition, UnitPiece defender, BoardPosition defenderPosition)
{
BattleResult result = UnitUtilities.ResolveBattle(attacker.Rank, defender.Rank);
// Based on result, update players
switch (result)
{
case BattleResult.Success:
{
// Remove from defender owner
defender.Owner.Pieces.Remove(defender);
break;
}
case BattleResult.Fail:
{
// Remove from attacker owner
attacker.Owner.Pieces.Remove(attacker);
break;
}
case BattleResult.Split:
{
//Remove both
attacker.Owner.Pieces.Remove(attacker);
defender.Owner.Pieces.Remove(defender);
break;
}
default:
{
break;
}
}
EventManager.Raise(new UnitBattleResultEvent(attacker, defender, attackerPosition, defenderPosition, result));
turnComplete = true;
}
/// <summary>
///
/// </summary>
/// <param name="boardPositions"></param>
public Board(BoardPosition[,] boardPositions)
{
this.EvaluationValue = 0;
amountOfRedItems = 0;
amountOfWhiteItems = 0;
this.boardPositions = boardPositions;
CalculateMovableTiles();
}
public UnitBattleResultEvent(UnitPiece attacker, UnitPiece defender, BoardPosition attackerPosition, BoardPosition defenderPosition, BattleResult result)
: base(attacker)
{
this.defender = defender;
this.result = result;
this.attackerPosition = attackerPosition;
this.defenderPosition = defenderPosition;
}
public void Constructor_GivenInternalFile8_ThrowsException()
{
try {
BoardPosition boardPosition = new BoardPosition(8, 0);
Assert.Fail("Expected a ChessBoardException to be thrown!");
}
catch (ChessBoardException ex) {
Assert.That(ex.ExceptionReason, Is.EqualTo(ExceptionReason.InvalidBoardPosition));
}
}
public void Constructor_GivenFileaRank1_Succeeds()
{
BoardPosition boardPosition = new BoardPosition('a', 1);
Assert.That(boardPosition.File, Is.EqualTo('a'));
Assert.That(boardPosition.Rank, Is.EqualTo(1));
Assert.That(boardPosition.InternalFile, Is.EqualTo(0));
Assert.That(boardPosition.InternalRank, Is.EqualTo(0));
Assert.That(boardPosition.Name, Is.EqualTo("a1"));
}
public IList<ValidationError> ValidateMove(Game game, Enums.PlayerType owner, BoardPosition boardPosition)
{
var warnings = new List<ValidationError>();
var isMoveLegitimate = _moveValidationSpecification.IsMoveValid(game, owner, boardPosition);
if(!isMoveLegitimate)
warnings.Add(new ValidationError { Type = "InvalidMove", Message = "Sorry this move is not legal, try another move to keep playing." });
return warnings;
}
public GameMove Build(Enums.PlayerType owner, BoardPosition position)
{
var move = new GameMove
{
Id = _id,
Owner = owner,
Position = position
};
return move;
}
public static GameMove CreateFrom(Enums.PlayerType owner, BoardPosition position)
{
var move = new GameMove
{
Id = Guid.NewGuid(),
Owner = owner,
Position = position
};
return move;
}
public void Can_Clear_Piece_From_Position()
{
// arrange
var boardPosition = new BoardPosition(1, 1, new Piece(2, 3, PieceColor.Green));
// act
boardPosition.ClearPieceFromPosition();
// assert
Assert.IsFalse(boardPosition.ContainsPiece());
}
public BoardPosition PlayTurn(TicTacToeBoard board)
{
var random = new Random();
BoardPosition move;
do
{
move = new BoardPosition(random.Next(1, 4), random.Next(1, 4));
} while (!board.SquareIsFree(move));
return move;
}
public static bool IsPositionInBattleSquare(BoardPosition boardPosition)
{
if (boardPosition.Row >= outerBoarderSquareCount + 1 && boardPosition.Row <= rowCount - outerBoarderSquareCount)
{
if (boardPosition.Column >= outerBoarderSquareCount + 1 && boardPosition.Column <= columnCount - outerBoarderSquareCount)
{
return true;
}
}
return false;
}
public void Verifies_If_Board_Position_Is_Occupied_By_Piece()
{
// arrange
var boardPositionWithPiece = new BoardPosition(1, 1, new Piece(2, 3, PieceColor.Green));
var boardPositionWithoutPiece = new BoardPosition(1, 1);
// act
// assert
Assert.IsTrue(boardPositionWithPiece.ContainsPiece());
Assert.IsFalse(boardPositionWithoutPiece.ContainsPiece());
}
public Transform GetTransformForPosition(BoardPosition position)
{
Transform transform = default(Transform);
GameObject target = null;
if(board.TryGetValue(position, out target))
{
transform = target.transform;
}
return transform;
}
public void Sets_Row_And_Column_Only_On_Instantiation()
{
// arrange
var positionRow = 3;
var positionColumn = 4;
// act
var boardPosition = new BoardPosition(positionRow, positionColumn);
// assert
Assert.AreEqual(positionRow, boardPosition.Row);
Assert.AreEqual(positionColumn, boardPosition.Column);
}
public void AddPiece(BoardPosition position, UnitRank rank)
{
//Check for existing piece, remove it if needed.
//Debug.Log("atteming to add " + UnitUtilities.ReadableRank(rank) + " at " + position.ToString());
bool equal = false;
if (pieces.ContainsKey(position))
{
UnitPiece existing;
if (pieces.TryGetValue(position, out existing))
{
if (existing.Rank.Equals(rank))
{
//We're not going to remove then add the same exact piece to the same position
equal = true;
}
else
{
RemovePiece(position);
}
}
}
if (!equal)
{
Transform target = BoardManager.GetTransformForPosition(position);
if (!EqualityComparer<Transform>.Default.Equals(target, default(Transform)))
{
GameObject plane = Instantiate(UnitPlane);
UnitPiece piece = GeneratePiece(rank, plane);
if (piece.Owner != null)
{
piece.Piece.transform.SetParent(piece.Owner.Holder.transform);
plane.name = UnitUtilities.ReadableRank(rank);
plane.layer = LayerMask.NameToLayer("Pieces");
Vector3 planePos = target.position;
planePos.z = GOLayer.UNIT_LAYER;
plane.transform.position = planePos;
Renderer r = plane.GetComponent<Renderer>();
r.material = MaterialManager.GetRankMaterial(rank);
pieces.Add(position, piece);
EventManager.Raise(new UnitPlacedEvent(position, piece));
}
else
{
piece.Destroy();
Destroy(plane);
}
}
}
}
public void Sets_Row_And_Column_And_Piece_On_Instantiation()
{
// arrange
var positionRow = 3;
var positionColumn = 4;
var piece = new Piece(3, 4, PieceColor.Orange);
// act
var boardPosition = new BoardPosition(positionRow, positionColumn, piece);
// assert
Assert.AreEqual(positionRow, boardPosition.Piece.Row);
Assert.AreEqual(positionColumn, boardPosition.Column);
}
public BreakthroughMoveResults(bool success, IPawn pawnKilled, BoardPosition start, BoardPosition end, bool gameOver, Player winner) {
Success = success;
GameOver = gameOver;
Winner = winner;
Path = new List<BoardPosition>(2);
Path.Add(start);
Path.Add(end);
PawnsKilled = new List<IPawn>(1);
if (pawnKilled != null) {
PawnsKilled.Add(pawnKilled);
}
}
static void ProcessBoard(BoardPosition[] board, int startPosition)
{
var position = startPosition;
while (position < 100)
{
var currentPosition = board[position];
var nextPosition = board[position + 1];
var nextThrowsAndDice = currentPosition.ThrowsAndDice.Advance();
nextPosition.SetThrowsAndDice(nextThrowsAndDice);
if (currentPosition.JumpToPosition.HasValue)
{
var targetPosition = board[currentPosition.JumpToPosition.Value];
var isUpdated = targetPosition.SetThrowsAndDice(currentPosition.ThrowsAndDice.Reset());
if (currentPosition.IsSnake)
{
if (isUpdated)
{
position = currentPosition.JumpToPosition.Value;
continue;
}
else if(currentPosition.ThrowsAndDice.DiceEyes == 6)
{
var nextSetPosition = FindNextNoSnakeSetPosition(board, position + 1);
if (nextSetPosition == -1)
{
if (board[100].ThrowsAndDice == null)
{
board[100].ThrowsAndDice = new ThrowsAndDice();
}
board[100].ThrowsAndDice.Throws = -1;
break;
}
else
{
position = nextSetPosition;
continue;
}
}
}
}
position++;
}
Console.WriteLine(board[100].ThrowsAndDice.Throws);
}
private IEnumerable<ITicTacToePlayer> GenerateLine(Predicate<BoardPosition> equation)
{
var e = _boardStatus.GetEnumerator();
for (var row = _boundaries.TopLeft.Row; row <= _boundaries.BottomRight.Row; row++)
{
for (var column = _boundaries.TopLeft.Column; column <= _boundaries.BottomRight.Column; column++)
{
var position = new BoardPosition(row, column);
e.MoveNext();
if(equation(position))
yield return e.Current;
}
}
}
public CheckersMoveResults(bool success, bool turnOver, IPawn pawnKilled, BoardPosition start, BoardPosition end, bool gameOver, Player winner, bool becameKing) {
Success = success;
TurnOver = turnOver;
GameOver = gameOver;
Winner = winner;
Path = new List<BoardPosition>(2);
Path.Add(start);
Path.Add(end);
PawnsKilled = new List<IPawn>(1);
if (pawnKilled != null) {
PawnsKilled.Add(pawnKilled);
}
BecameKing = becameKing;
}
public ChessPosition( int nPosRank, int nPosPile )
{
this.posType = GetPositionType( nPosRank, nPosPile );
if( this.posType != BoardPositionType.eNone ) {
this.nRank = nPosRank;
this.nPile = nPosPile;
this.pos = (BoardPosition)(nPosPile * ChessData.nNumRank + nPosRank);
}
else {
this.nRank = -1;
this.nPile = -1;
this.pos = BoardPosition.InvalidPosition;
}
}
public void Sets_Row_And_Column_For_Piece_When_Set_To_Position()
{
// arrange
var piece = new Piece(3, 4, PieceColor.Orange);
// act
var boardPosition = new BoardPosition(1, 1, piece);
var firstPieceRow = boardPosition.Piece.Row;
var firstPieceColumn = boardPosition.Piece.Column;
boardPosition.SetPiece(new Piece(5, 6, PieceColor.Green));
// assert
Assert.AreEqual(1, boardPosition.Row);
Assert.AreEqual(1, boardPosition.Column);
Assert.AreEqual(1, firstPieceRow);
Assert.AreEqual(1, firstPieceColumn);
Assert.AreEqual(1, boardPosition.Piece.Row);
Assert.AreEqual(1, boardPosition.Piece.Column);
}
public ChessPosition( BoardPosition boardPos )
{
int nPosRank = 0, nPosPile = 0;
this.posType = ChessPosition.CalcPositionIndex( boardPos, ref nPosRank, ref nPosPile );
if( this.posType != BoardPositionType.eNone ) {
this.nRank = nPosRank;
this.nPile = nPosPile;
this.pos = boardPos;
}
else {
this.nRank = -1;
this.nPile = -1;
this.pos = BoardPosition.InvalidPosition;
}
}
public Board()
{
this.Positions = new BoardPosition[columnCount, rowCount];
for (int row = 1; row <= rowCount; row++)
{
for (int column = 1; column <= columnCount; column++)
{
var boardPosition = new BoardPosition(row, column);
// assign a piece to the position if it is not in the battle square
if (!IsPositionInBattleSquare(boardPosition))
{
var pieceColor = (row % 2 == 0 && column % 2 == 0 || row % 2 != 0 && column % 2 != 0) ? PieceColor.Green : PieceColor.Orange;
boardPosition.SetPiece(new Piece(0, 0, pieceColor));
}
this.Positions[row - 1, column - 1] = boardPosition;
}
}
}
public JumpTree(BoardPosition root, IEnumerable<BoardPosition> targets, GameBoard board)
{
_root = new JumpTreeNode
{
Depth = 0,
Position = root,
Board = board
};
NodeCount = 1;
foreach (BoardPosition pos in targets)
{
GameBoard boardCopy = _root.Board.Copy();
SimpleMove move = new SimpleMove(boardCopy[_root.Position].Occupation, _root.Position, pos, boardCopy[_root.Position].Piece == PieceType.King);
boardCopy.SetCapture(move);
boardCopy.DoMove(move, true);
_root.Children.Add(new JumpTreeNode { Board = boardCopy, Depth = _root.Depth + 1, Parent = _root, Position = pos, CheckAgain = !move.IsUpgrade });
++NodeCount;
}
}
public BoardPositionEvent(BoardPosition position)
{
this.position = position;
}
/// <summary>
/// Constructs a ChessMove that moves a piece from one position to another
/// </summary>
/// <param name="start">the starting position of the piece to move</param>
/// <param name="end">the position where the piece will end up</param>
public ChessMove(BoardPosition start, BoardPosition end)
{
StartPosition = start;
EndPosition = end;
MoveType = ChessMoveType.Normal;
}
/// <summary>
/// Constructs a ChessMove that performs a "special" move from one position to another.
/// </summary>
/// <param name="start">the starting position of the piece to move</param>
/// <param name="end">the position where the piece will end up</param>
/// <param name="type">the special chess move type to perform</param>
public ChessMove(BoardPosition start, BoardPosition end, ChessMoveType type) :
this(start, end)
{
MoveType = type;
}
public SpawnInfo(PieceInfo piece, BoardPosition newPosition)
{
PieceInfo = piece;
NewPosition = newPosition;
}
public PlayerModel(BoardPosition initialPosition, int lives)
{
this.position = initialPosition;
this.numberOfLives = lives;
this.numberOfMoves = 0;
}
/// <summary> /// Looks up a ChessPiece by position on the board /// </summary> /// <param name="pos">The position the query</param> /// <returns>A ChessPiece reference or null</returns> public ChessPiece GetPieceByPosition(BoardPosition pos) => _board.GetPieceByPosition(pos);
public BoardTileType getValueForPosition(BoardPosition position)
{
return(board[position.x, position.y]);
}
//
// Summary:
// Create an array with the movements actually avaliable to the Dame.
//
// Returns:
// An array of booleans with the same size of the board where the
// positions contain a true value if it is a possible movement;
// otherwise it contains false.
public override bool[,] PossibleTargets()
{
// 4-----1
// -4---1-
// --8-5--
// ---D---
// --7-6--
// -3---2-
// 3-----2
bool[,] possibleTargets = new bool[Board.Height, Board.Width];
TwoDimensionsArrayPosition arrPos = BoardPosition.ToArrayPosition(Board.Height);
bool withoutCaptures = true;
// NE (1) (Only catch avaliable)
for (int arrRow = arrPos.Row - 1, arrColumn = arrPos.Column + 1; arrRow >= 0 && arrColumn < Board.Width; arrRow--, arrColumn++)
{
if (Board.Pieces(arrRow, arrColumn) != null)
{
if (Board.Pieces(arrRow, arrColumn).Team != Team && arrRow - 1 >= 0 && arrColumn + 1 < Board.Width && Board.Pieces(arrRow - 1, arrColumn + 1) == null)
{
possibleTargets[arrRow - 1, arrColumn + 1] = true;
withoutCaptures = false;
break;
}
else
{
break;
}
}
}
// SE (2) (Only catch avaliable)
for (int arrRow = arrPos.Row + 1, arrColumn = arrPos.Column + 1; arrRow < Board.Height && arrColumn < Board.Width; arrRow++, arrColumn++)
{
if (Board.Pieces(arrRow, arrColumn) != null)
{
if (Board.Pieces(arrRow, arrColumn).Team != Team && arrRow + 1 < Board.Height && arrColumn + 1 < Board.Width && Board.Pieces(arrRow + 1, arrColumn + 1) == null)
{
possibleTargets[arrRow + 1, arrColumn + 1] = true;
withoutCaptures = false;
break;
}
else
{
break;
}
}
}
// SW (3) (Only catch avaliable)
for (int arrRow = arrPos.Row + 1, arrColumn = arrPos.Column - 1; arrRow < Board.Height && arrColumn >= 0; arrRow++, arrColumn--)
{
if (Board.Pieces(arrRow, arrColumn) != null)
{
if (Board.Pieces(arrRow, arrColumn).Team != Team && arrRow + 1 < Board.Height && arrColumn - 1 >= 0 && Board.Pieces(arrRow + 1, arrColumn - 1) == null)
{
possibleTargets[arrRow + 1, arrColumn - 1] = true;
withoutCaptures = false;
break;
}
else
{
break;
}
}
}
// NW (4) (Only catch avaliable)
for (int arrRow = arrPos.Row - 1, arrColumn = arrPos.Column - 1; arrRow >= 0 && arrColumn >= 0; arrRow--, arrColumn--)
{
if (Board.Pieces(arrRow, arrColumn) != null)
{
if (Board.Pieces(arrRow, arrColumn).Team != Team && arrRow - 1 >= 0 && arrColumn - 1 >= 0 && Board.Pieces(arrRow - 1, arrColumn - 1) == null)
{
possibleTargets[arrRow - 1, arrColumn - 1] = true;
withoutCaptures = false;
break;
}
else
{
break;
}
}
}
if (withoutCaptures)
{
// NE (5) (Without catch case)
if (arrPos.Row - 1 >= 0 && arrPos.Column + 1 < Board.Width && Board.Pieces(arrPos.Row - 1, arrPos.Column + 1) == null)
{
possibleTargets[arrPos.Row - 1, arrPos.Column + 1] = true;
}
// SE (6) (Without catch case)
if (arrPos.Row + 1 < Board.Height && arrPos.Column + 1 < Board.Width && Board.Pieces(arrPos.Row + 1, arrPos.Column + 1) == null)
{
possibleTargets[arrPos.Row + 1, arrPos.Column + 1] = true;
}
// SW (7) (Without catch case)
if (arrPos.Row + 1 < Board.Height && arrPos.Column - 1 >= 0 && Board.Pieces(arrPos.Row + 1, arrPos.Column - 1) == null)
{
possibleTargets[arrPos.Row + 1, arrPos.Column - 1] = true;
}
// NW (8) (Without catch case)
if (arrPos.Row - 1 >= 0 && arrPos.Column - 1 >= 0 && Board.Pieces(arrPos.Row - 1, arrPos.Column - 1) == null)
{
possibleTargets[arrPos.Row - 1, arrPos.Column - 1] = true;
}
}
return(possibleTargets);
}
private void UpdateBoard(BoardPosition[,] boardState, BoardPosition move, TeamName teamName)
{
boardState[move.XIndex, move.YIndex].IsOccupied = true;
boardState[move.XIndex, move.YIndex].Owner = teamName;
}
public TicTacToeMove(BoardPosition position)
{
Position = position;
}
private void CreatePieceFactory(BoardPosition position)
{
var bKing = position.Where(x => x.Value == 'k').ToList();
var wKing = position.Where(x => x.Value == 'K').ToList();
if (wKing.Count != 1 || bKing.Count != 1)
{
return;
}
this.WhiteKing = new King(true, this.GetCell, wKing[0].Key);
this.BlackKing = new King(false, this.GetCell, bKing[0].Key);
foreach (KeyValuePair <string, char> kvp in position)
{
if (kvp.Value == 'K')
{
this.GetCell(kvp.Key).CurrentPiece = this.WhiteKing;
}
else if (kvp.Value == 'k')
{
this.GetCell(kvp.Key).CurrentPiece = this.BlackKing;
}
else
{
var cell = this.GetCell(kvp.Key);
switch (kvp.Value)
{
case 'R':
cell.CurrentPiece = new Rook(true, this.GetCell, kvp.Key, this.BlackKing);
break;
case 'r':
cell.CurrentPiece = new Rook(false, this.GetCell, kvp.Key, this.WhiteKing);
break;
case 'N':
cell.CurrentPiece = new Knight(true, this.GetCell, kvp.Key);
break;
case 'n':
cell.CurrentPiece = new Knight(false, this.GetCell, kvp.Key);
break;
case 'B':
cell.CurrentPiece = new Bishop(true, this.GetCell, kvp.Key, this.BlackKing);
break;
case 'b':
cell.CurrentPiece = new Bishop(false, this.GetCell, kvp.Key, this.WhiteKing);
break;
case 'Q':
cell.CurrentPiece = new Queen(true, this.GetCell, kvp.Key, this.BlackKing);
break;
case 'q':
cell.CurrentPiece = new Queen(false, this.GetCell, kvp.Key, this.WhiteKing);
break;
case 'P':
cell.CurrentPiece = new Pawn(true, this.GetCell, kvp.Key);
break;
case 'p':
cell.CurrentPiece = new Pawn(false, this.GetCell, kvp.Key);
break;
default:
break;
}
}
}
}
// Update is called once per frame
void Update()
{
hideHandPos = defaultHandPos + hideHandOffset;
Ray mouseRay = cam.ScreenPointToRay(Input.mousePosition);
RaycastHit interfaceHit = new RaycastHit();
Physics.Raycast(mouseRay, out interfaceHit);
if (Input.GetMouseButtonDown(1))
{
selectify = null;
}
if (selectify != null)
{
selectShow.SetActive(true);
selectShow.transform.position = selectify.transform.position;
selectShow.transform.rotation = selectify.transform.rotation;
selectShow.transform.position -= selectify.transform.forward * .005f;
actionLine.positionCount = 0;
hand.transform.position = hand.transform.position * (1 - Time.deltaTime) + hideHandPos * Time.deltaTime;
}
else
{
hand.transform.position = hand.transform.position * (1 - Time.deltaTime) + defaultHandPos * Time.deltaTime;
targetBoard.SetActive(false);
}
if (interfaceHit.collider)
{
Debug.DrawLine(new Vector3(0, 0, 0), interfaceHit.transform.position);
Card rayCard = interfaceHit.collider.GetComponent <Card>();
BoardPosition bordComp = interfaceHit.collider.GetComponent <BoardPosition>();
if (selectify != null && selectify.type == Card.cardType.targetBoard && rayCard == null)
{
targetBoard.SetActive(true);
}
else
{
targetBoard.SetActive(false);
}
if (Input.GetMouseButtonDown(0) && rayCard != null)
{
if (rayCard.state == Card.cardState.onboard && selectify != null)
{
if (rayCard.isValidTarget(selectify))
{
hand.removeCard(selectify);
rayCard.playCardToThis(selectify);
selectify = null;
}
}
if (hand.hand.Contains(rayCard))
{
selectify = rayCard;
}
}
else if (Input.GetMouseButtonDown(0) && bordComp != null && selectify != null)
{
if (bordComp.isPlayableHere(selectify))
{
hand.removeCard(selectify);
if (selectify.type == Card.cardType.targetBoard)
{
bool applyOnce = false;
foreach (BoardPosition pos in hand.board.boardPositions)
{
if (pos.unitCard != null && pos.unitCard.type == Card.cardType.creature)
{
Debug.Log("attempt");
selectify.GetComponent <targetAction>().actOnTarget(pos.unitCard);
applyOnce = true;
}
}
/*for (int col = 0; col <= 4; col++)
* {
* for(int row = 0; row <= 7; row++)
* {
* Debug.Log("pos" + row + ":" + col);
* BoardPosition applypos = hand.board.getBoardPosition(row, col);
* if (applypos.unitCard != null && applypos.unitCard.type == Card.cardType.creature)
* {
* Debug.Log("attempt");
* selectify.GetComponent<targetAction>().actOnTarget(applypos.unitCard);
* applyOnce = true;
* }
* }
* }*/
selectify.transform.parent = null;
selectify.transform.position = new Vector3(0, 2, 0);
if (!applyOnce)
{
Destroy(selectify);
}
}
else
{
hand.board.addCardToBoard(selectify, bordComp.row, bordComp.col, hand.dir);
}
selectify = null;
}
}
if ((selectify != null && (selectify.type != Card.cardType.targetBoard))
&&
((bordComp != null && bordComp.isPlayableHere(selectify)) || (rayCard != null && rayCard.isValidTarget(selectify))))
{
if (selectify.type == Card.cardType.targetCol)
{
if (bordComp != null)
{
targetCol.SetActive(true);
targetCol.transform.position = bordComp.transform.position - new Vector3(0, 0, bordComp.transform.position.z);
}
}
else if (selectify.type == Card.cardType.targetRow)
{
if (bordComp != null)
{
targetRow.SetActive(true);
targetRow.transform.position = bordComp.transform.position - new Vector3(bordComp.transform.position.x, 0, 0);
}
}
else
{
GameObject targ = bordComp != null ? bordComp.gameObject : rayCard.gameObject;
targetShow.SetActive(true);
targetShow.transform.position = targ.transform.position + targ.transform.forward * .05f;
if (bordComp != null)
{
targetShow.transform.rotation = new Quaternion(1, 0, 0, 1);
}
else
{
targetShow.transform.rotation = targ.transform.rotation;
}
}
}
else
{
targetShow.SetActive(false);
}
if (selectify != null && (
bordComp != null && bordComp.isPlayableHere(selectify) ||
rayCard != null && rayCard.isValidTarget(selectify)
))
{
actionLine.positionCount = 20;
Debug.DrawLine(selectify.transform.position, interfaceHit.transform.position);
for (int i = 0; i < actionLine.positionCount; i++)
{
float percentLine = i / (actionLine.positionCount - 1f);
float leanBias = selectify.transform.position.x > 0 ? Mathf.Sin(percentLine * Mathf.PI) : -Mathf.Sin(percentLine * Mathf.PI);
Vector3 hoverHeight = new Vector3(leanBias * 2, Mathf.Sin(percentLine * Mathf.PI) * 4, 0);
actionLine.SetPosition(i, selectify.transform.position * (1 - percentLine) + hoverHeight + interfaceHit.transform.position * percentLine);
}
if (rayCard != null)
{
targetShow.SetActive(true);
targetShow.transform.position = interfaceHit.transform.position - interfaceHit.transform.forward * .05f;
}
else if (bordComp != null && selectify.type != Card.cardType.targetBoard)
{
targetShow.SetActive(true);
targetShow.transform.position = interfaceHit.transform.position + interfaceHit.transform.forward * .05f;
}
}
else if (selectify == null)
{
selectShow.SetActive(false);
}
}
else
{
targetShow.SetActive(false);
targetBoard.SetActive(false);
}
}
//
// Summary:
// The basic contructor of the Dame that only pass its own the
// parameters to its own superclass.
//
// Parameters:
// boardPosition:
// The position of this piece in the board.
//
// board:
// The board on which the piece belongs.
//
// team:
// The team of the piece.
public Dame(BoardPosition boardPosition, Board.Board board, Team team) : base("D", boardPosition, board, team)
{
}
/// <summary> /// Generates all the possible moves of a piece /// </summary> /// <param name="pos">Position of the piece to query</param> /// <returns>A sequence of moves and their type</returns> public IEnumerable <MoveResult> PossibleMoves(BoardPosition pos) => _board.PossibleMoves(pos);
public void InitializeBoard(BoardPosition position)
{
InitializeCells();
CreatePieceFactory(position);
}
public void InitialBoard8x8()
{
var board = BoardPosition.InitialSetup(8);
board.Should().Be(BoardPosition.FromString("4444,4444,4444,0000,0000,5555,5555,5555", ","));
}
public ChessBoard(BoardPosition position) : this()
{
this.InitializeBoard(position);
this.InitializeKingComponents();
this.UpdateBoardState();
}
public void GenerateSmartSpawns()
{
// Get all my pieces
List <PieceInfo> piecesToSpawn = new List <PieceInfo>(myPieces.AllPieces.Count);
foreach (PieceInfo piece in myPieces.AllPieces)
{
piecesToSpawn.Add(piece);
}
// Get rows
int backRow = side == Side.A ? 0 : 7;
int midRow = side == Side.A ? 1 : 6;
// 75% to spawn flag on back row
// 25% to spawn flag on mid row
PieceInfo flag = ExtractPieceFromList(piecesToSpawn, PieceRank.Flag);
BoardPosition flagPos = new BoardPosition(
Random.Range(0, Board.WIDTH),
Random.value > 0.25f ? backRow : midRow);
gameManager.SpawnPiece(new SpawnInfo(flag, flagPos));
// Get guard pieces for the flag
PieceInfo guard1 = ExtractPieceFromList(piecesToSpawn, PieceRank.Spy);
PieceInfo guard2 = ExtractPieceFromList(piecesToSpawn, PieceRank.Private);
// 3rd guard can be 3, 4, or 5 star general, equally likely
PieceRank guard3Rank = PieceRank.General5;
float guard3Chance = Random.value;
if (guard3Chance > 0.3333f)
{
guard3Rank = PieceRank.General3;
}
else if (guard3Chance > 0.6666f)
{
guard3Rank = PieceRank.General4;
}
PieceInfo guard3 = ExtractPieceFromList(piecesToSpawn, guard3Rank);
// Get guard spawns
List <BoardPosition> guardSpawns = new List <BoardPosition>();
// Add sides
AddBoardPositionIfValid(guardSpawns, flagPos.Left);
AddBoardPositionIfValid(guardSpawns, flagPos.Right);
// Add next row
if (side == Side.A)
{
AddBoardPositionIfValid(guardSpawns, flagPos.UpperLeft);
AddBoardPositionIfValid(guardSpawns, flagPos.Up);
AddBoardPositionIfValid(guardSpawns, flagPos.UpperRight);
}
else
{
AddBoardPositionIfValid(guardSpawns, flagPos.DownLeft);
AddBoardPositionIfValid(guardSpawns, flagPos.Down);
AddBoardPositionIfValid(guardSpawns, flagPos.DownRight);
}
// Randomize spawns
guardSpawns.Shuffle();
// Spawn guard pieces
gameManager.SpawnPiece(new SpawnInfo(guard1, guardSpawns[0]));
gameManager.SpawnPiece(new SpawnInfo(guard2, guardSpawns[1]));
gameManager.SpawnPiece(new SpawnInfo(guard3, guardSpawns[2]));
// List all possible spawns
float leftValue = 0f;
float midValue = 0f;
float rightValue = 0f;
List <BoardPosition> leftFlank = new List <BoardPosition>();
List <BoardPosition> midFlank = new List <BoardPosition>();
List <BoardPosition> rightFlank = new List <BoardPosition>();
// Left flank
for (int i = 0; i < Board.WIDTH / 3; i++)
{
for (int j = minSpawnHeight; j <= maxSpawnHeight; j++)
{
PieceInfo pieceInfo = board.GetPieceFromPosition(i, j);
if (pieceInfo != null)
{
leftValue += pieceInfo.Rank.GetValue();
}
else
{
leftFlank.Add(new BoardPosition(i, j));
}
}
}
// Middle flank
for (int i = Board.WIDTH / 3; i < Board.WIDTH / 3 * 2; i++)
{
for (int j = minSpawnHeight; j <= maxSpawnHeight; j++)
{
PieceInfo pieceInfo = board.GetPieceFromPosition(i, j);
if (pieceInfo != null)
{
midValue += pieceInfo.Rank.GetValue();
}
else
{
midFlank.Add(new BoardPosition(i, j));
}
}
}
// Right flank
for (int i = Board.WIDTH / 3 * 2; i < Board.WIDTH; i++)
{
for (int j = minSpawnHeight; j <= maxSpawnHeight; j++)
{
PieceInfo pieceInfo = board.GetPieceFromPosition(i, j);
if (pieceInfo != null)
{
rightValue += pieceInfo.Rank.GetValue();
}
else
{
rightFlank.Add(new BoardPosition(i, j));
}
}
}
// Types of spawns. Both equally likely
// 1. Conservative - Equally distribute to all 3 flanks
// 2. Blitz - Concentrate power in 1 flank
if (Random.value > 0.5f)
{
// Conservative - Equally distribute
Debug.Log("Conservative spawning");
// Shuffle first
piecesToSpawn.Sort((pieceInfo1, pieceInfo2) => pieceInfo2.Rank.GetValue().CompareTo(pieceInfo1.Rank.GetValue()));
leftFlank.Shuffle();
midFlank.Shuffle();
rightFlank.Shuffle();
while (piecesToSpawn.Count > 0)
{
PieceInfo pieceToSpawn = ExtractPieceFromList(piecesToSpawn, piecesToSpawn[0].Rank);
// Find smallest flank in terms of value
if (leftValue <= midValue && leftValue <= rightValue && leftFlank.Count > 0)
{
SpawnPieceFromPositionList(leftFlank, pieceToSpawn);
leftValue += pieceToSpawn.Rank.GetValue();
}
else if (midValue <= leftValue && midValue <= rightValue && midFlank.Count > 0)
{
SpawnPieceFromPositionList(midFlank, pieceToSpawn);
midValue += pieceToSpawn.Rank.GetValue();
}
else
{
SpawnPieceFromPositionList(rightFlank, pieceToSpawn);
rightValue += pieceToSpawn.Rank.GetValue();
}
}
}
else
{
// Blitz
Debug.Log("Blitz spawning");
piecesToSpawn.Sort((pieceInfo1, pieceInfo2) => pieceInfo2.Rank.GetValue().CompareTo(pieceInfo1.Rank.GetValue()));
// Choose 1 flank
List <BoardPosition> chosenFlank;
List <BoardPosition> otherFlanks;
float flankChance = Random.value;
if (flankChance < 0.3333f)
{
chosenFlank = leftFlank;
otherFlanks = midFlank;
otherFlanks.AddRange(rightFlank);
}
else if (flankChance < 0.6666f)
{
chosenFlank = midFlank;
otherFlanks = leftFlank;
otherFlanks.AddRange(rightFlank);
}
else
{
chosenFlank = rightFlank;
otherFlanks = leftFlank;
otherFlanks.AddRange(midFlank);
}
chosenFlank.Shuffle();
otherFlanks.Shuffle();
foreach (PieceInfo piece in piecesToSpawn)
{
// If chosen flank is not empty,
if (chosenFlank.Count > 0)
{
// 80% chosen blitz flank
// 20% for other flanks
flankChance = Random.value;
if (flankChance < 0.8f)
{
SpawnPieceFromPositionList(chosenFlank, piece);
}
else
{
SpawnPieceFromPositionList(otherFlanks, piece);
}
}
else
{
SpawnPieceFromPositionList(otherFlanks, piece);
}
}
}
}
public void OnRoundCompletion()
{
_lastMove = null;
}
public void setTileForPosition(BoardPosition position, BoardTileType tileType)
{
board[position.x, position.y] = tileType;
}
