public IEnumerable <Board> GetBoards(BoardQuery query)
{
var res = _unitOfWork.Repository <Board>().Include(x => x.BoardUsers).ThenInclude(x => x.User);
if (string.IsNullOrEmpty(query.Name))
{
return(res);
}
return(res.Where(x => x.Name.ToLower().Contains(query.Name.ToLower())));
}
public override IEnumerable <Square> GetAvailableMoves(Board board)
{
Square mySquare = board.FindPiece(this);
List <Square> availableMoves = new List <Square>();
foreach (MoveOffset moveOffset in MoveOffsets)
{
availableMoves.Add(mySquare + moveOffset);
}
return(availableMoves.Where(BoardQuery.IsWithinBounds).Where(square => !BoardQuery.IsSameColourOnSquares(board, mySquare, square)));
}
private Square?GetFirstMoveSquare(Board board, int moveDirection)
{
Square mySquare = board.FindPiece(this);
Square?availableMove = null;
if (!HasEverMoved && BoardQuery.IsWithinBounds(mySquare + new MoveOffset(moveDirection, 0)) &&
board.GetPiece(mySquare + new MoveOffset(moveDirection, 0)) == null)
{
availableMove = mySquare + new MoveOffset(moveDirection * 2, 0);
}
return(availableMove);
}
void Awake()
{
boardBomber = GetComponent <BoardBomber>();
boardClearer = GetComponent <BoardClearer>();
boardCollapser = GetComponent <BoardCollapser>();
boardDeadlock = GetComponent <BoardDeadlock>();
boardFiller = GetComponent <BoardFiller>();
boardHighlighter = GetComponent <BoardHighlighter>();
boardInput = GetComponent <BoardInput>();
boardMatcher = GetComponent <BoardMatcher>();
boardQuery = GetComponent <BoardQuery>();
boardSetup = GetComponent <BoardSetup>();
boardShuffler = GetComponent <BoardShuffler>();
boardTiles = GetComponent <BoardTiles>();
}
private List <Square> GetSquaresCanAttack(Board board, int moveDirection)
{
Square mySquare = board.FindPiece(this);
List <Square> availableMoves = new List <Square>();
for (int colOffset = -1; colOffset < 2; colOffset += 2)
{
Square captureSquare = mySquare + new MoveOffset(moveDirection, colOffset);
if (BoardQuery.IsWithinBounds(captureSquare) &&
BoardQuery.IsOppositeColourOnSquares(board, mySquare, captureSquare))
{
availableMoves.Add(captureSquare);
}
}
return(availableMoves);
}
public async Task <JsonResult> OnGetInitialAsync()
{
Init();
var board = await BoardQuery.SingleAsync().ConfigureAwait(false);
var userBoardViewModel = _mapper.Map <UserLeaderboardViewModel>(board);
userBoardViewModel.IsMember = false;
userBoardViewModel.IsRecommended = false;
userBoardViewModel.ViewUrl = Url.Page("/Boards/View", board.ViewArgs);
userBoardViewModel.JoinUrl = Url.Page("/Boards/View", "join", board.ViewArgs);
var scores = _scoresController.GetScores(new ScoresQuery
{
IsApproved = true,
BoardId = board.Id,
});
if (User.Identity.IsAuthenticated)
{
var user = await _userManager.GetCompleteUserAsync(User).ConfigureAwait(false);
var userViewModel = _mapper.Map <UserViewModel>(user);
userBoardViewModel.IsMember = await _ctx.Entry(user).Collection(b => b.UserLeaderboards).Query()
.AnyAsync(ub => ub.LeaderboardId == board.Id).ConfigureAwait(false);
userBoardViewModel.IsRecommended = await _userManager.GetRecommendedBoardsQuery(user)
.AnyAsync(b => b.Id == board.Id).ConfigureAwait(false);
return(new JsonResult(new ReactState
{
User = userViewModel,
Board = userBoardViewModel,
Scores = scores,
}));
}
return(new JsonResult(new ReactState
{
Board = userBoardViewModel,
Scores = scores,
}));
}
public static IEnumerable <Square> GetValidMovesInDirection(Board board, Square startingSquare, MoveOffset direction)
{
List <Square> validMoves = new List <Square>();
int distance = 1;
while (BoardQuery.IsWithinBounds(startingSquare + (direction * distance)) && board.GetPiece(startingSquare + (direction * distance)) == null)
{
validMoves.Add(startingSquare + (direction * distance));
distance += 1;
}
if (BoardQuery.IsWithinBounds(startingSquare + (direction * distance)) &&
!BoardQuery.IsSameColourOnSquares(board, startingSquare + (direction * distance), startingSquare))
{
validMoves.Add(startingSquare + (direction * distance));
}
return(validMoves);
}
private List <Square> GetSquaresEnPassant(Board board, int moveDirection)
{
Square mySquare = board.FindPiece(this);
List <Square> availableMoves = new List <Square>();
for (int colOffset = -1; colOffset < 2; colOffset += 2)
{
Square sidewaysSquare = mySquare + new MoveOffset(0, colOffset);
if (BoardQuery.IsWithinBounds(sidewaysSquare) &&
BoardQuery.IsOppositeColourOnSquares(board, mySquare, sidewaysSquare))
{
Square previousSquare = sidewaysSquare + new MoveOffset(moveDirection * 2, 0);
if (board.PreviousBoard[previousSquare.Row, previousSquare.Col] == board.GetPiece(sidewaysSquare))
{
availableMoves.Add(sidewaysSquare + new MoveOffset(moveDirection, 0));
}
}
}
return(availableMoves);
}
public SuccessResponse <IEnumerable <BoardOutputDto> > Get([FromQuery] BoardQuery query)
{
var res = _boardService.GetBoards(query).Select(_mapper.Map <BoardOutputDto>);
return(new SuccessResponse <IEnumerable <BoardOutputDto> >(res));
}
