protected List <Board.Move> GetMovesInDirection(Board.Direction direction, Board.Square square, Board.Square[,] board, bool multipleSquares = true, bool isPawn = false)
{
List <Board.Move> moves = new List <Board.Move>();
Board.Square s = Board.instance.GetSquareInDirection(square, direction, board);
Board.Square prevS = square;
while (s != prevS)
{
if (s.piece == null)
{
moves.Add(new Board.Move(s.file, s.rank, this));
}
else if (s.piece.color != color)
{
if (!isPawn)
{
moves.Add(new Board.Move(s.file, s.rank, this));
}
break;
}
else
{
break;
}
if (!multipleSquares)
{
break;
}
prevS = s;
s = Board.instance.GetSquareInDirection(s, direction, board);
}
return(moves);
}
public PieceMove GetNextMove(Vector3 StartLoc, BoardPiece cat, BoardSpace moveSpace, Board.Direction direction)
{
//movesIndex += 1;
PieceMove move = Moves[movesIndex];
if (move.GetMyType() == "Walk" && Board.GetBoardDistance(move.moveSpace.GetSpaceByDirection(direction).GetCenterPoint(), cat.transform.position) > 0.1f)
{
moveSpace = moveSpace.GetSpaceByDirection(direction);
Debug.Log("flipped " + moveSpace.name + " " + move.moveSpace.name);
Board.Direction flippedDir = Board.FlipDirection(direction);
cat.pieceDirection = flippedDir;
GetMoveFlipped(flippedDir, moveSpace);
return(move);
}
else if (movesIndex + 1 >= Moves.Count)
{
isActive = false;
return(null);
}
else
{
movesIndex += 1;
initializeMove(StartLoc, cat, moveSpace, direction, movesIndex);
return(GetMove());
}
}
public void InitializeMove(Vector3 StartLoc, BoardPiece myPiece, BoardSpace moveSpace, Board.Direction Direction, bool lastSpace)
{
this.myPiece = myPiece;
this.moveSpace = moveSpace;
this.Direction = Direction;
//StartLoc = myPiece.transform.position;
this.StartLoc = StartLoc;
InitializeMoveType(lastSpace);
}
public void GetNeighbor_GoesBeyondGrid_ReturnsHole(Board.Direction direction, int originCoordsX,
int originCoordsY)
{
var board = new Board(array2x2x1);
var origin = board[originCoordsX, originCoordsY];
var neighbor = board.GetNeighbor(origin as Tile, direction);
Assert.That(neighbor, Is.InstanceOf(typeof(Hole)));
}
public void GetNeighbor_SingleLayerBoard_NeighborIsCorrect(Board.Direction direction, char expectedLetter,
int expectedCoordX, int expectedCoordY)
{
var board = new Board(array3x3x1);
Tile centralTile = board[1, 1] as Tile;
var result = board.GetNeighbor(centralTile, direction) as Tile;
Assert.AreEqual(result.Letter, expectedLetter);
Assert.AreEqual(result.Coords.X, expectedCoordX);
Assert.AreEqual(result.Coords.Y, expectedCoordY);
}
// GetMovePositions(): given MoveType, MoveStep, currentCell, return list of Cells representing available moves
// .. return Vector2Int to decouple PieceManager and Board
// .. assume currentCell is valid
List <Vector2Int> GetMovePositions(BasePiece.MoveType moveType, BasePiece.MoveStep moveStep,
Cell currentCell, Board.Direction frontDirection)
{
Debug.Log("PieceManager::GetMovePositions()");
List <Vector2Int> result = new List <Vector2Int>();
Vector2Int currentPosition = currentCell.GetBoardPosition();
if (moveType == BasePiece.MoveType.Vertical)
{
List <Vector2Int> topPositions = GetDirectionPositions(Board.Direction.N, moveStep, currentCell, frontDirection);
topPositions.ForEach(position => result.Add(position));
List <Vector2Int> bottomPositions = GetDirectionPositions(Board.Direction.S, moveStep, currentCell, frontDirection);
bottomPositions.ForEach(position => result.Add(position));
}
else if (moveType == BasePiece.MoveType.Diagonal)
{
List <Vector2Int> topLeftPositions = GetDirectionPositions(Board.Direction.NW, moveStep, currentCell, frontDirection);
topLeftPositions.ForEach(position => result.Add(position));
List <Vector2Int> topRightPositions = GetDirectionPositions(Board.Direction.NE, moveStep, currentCell, frontDirection);
topRightPositions.ForEach(position => result.Add(position));
List <Vector2Int> bottomRightPositions = GetDirectionPositions(Board.Direction.SE, moveStep, currentCell, frontDirection);
bottomRightPositions.ForEach(position => result.Add(position));
List <Vector2Int> bottomLeftPositions = GetDirectionPositions(Board.Direction.SW, moveStep, currentCell, frontDirection);
bottomLeftPositions.ForEach(position => result.Add(position));
}
else if (moveType == BasePiece.MoveType.Horizontal)
{
List <Vector2Int> leftPositions = GetDirectionPositions(Board.Direction.W, moveStep, currentCell, frontDirection);
leftPositions.ForEach(position => result.Add(position));
List <Vector2Int> rightPositions = GetDirectionPositions(Board.Direction.E, moveStep, currentCell, frontDirection);
rightPositions.ForEach(position => result.Add(position));
}
else if (moveType == BasePiece.MoveType.L)
{
List <Vector2Int> lPositions = GetLPositions(currentCell);
lPositions.ForEach(position => result.Add(position));
}
else if (moveType == BasePiece.MoveType.Pawn)
{
List <Vector2Int> pawnPositions = GetPawnPositions(currentCell, frontDirection);
pawnPositions.ForEach(position => result.Add(position));
}
return(result);
}
public bool StartMoves(BoardPiece cat, BoardSpace startSpace, Board.Direction direction)
{
if (!isActive)
{
movesIndex = 0;
isActive = true;
initializeMove(cat.transform.position, cat, startSpace, direction, 0);
return(true);
}
else
{
return(false);
}
}
public void Refresh()
{
// Cogemos la dirección actual pulsada por el jugador en el teclado
direction = board.GetDirectionKeyboard();
// Por defecto increase_snake = false
bool increase_snake = false;
// Obtenemos la siguiente posición a la cabeza actual, antes de mover para realizar comprobaciones
Piece next_position = board.NextPiece(direction, GetHead());
// Si el snake se encuentra con otra posición de tipo BODY, terminará el juego
if (hasColision(Piece.Type.BODY))
{
throw new GameOverException(board);
}
// Si el tipo de la pieza actual es FOOD significa que ha encontrado comida
if (hasColision(Piece.Type.NORMAL_FOOD) || hasColision(Piece.Type.SPECIAL_FOOD))
{
// Seteamos increase_snake a true, informando que hay que incrementar el snake.body
increase_snake = true;
// Aumentamos puntuación del usuario en 1
board.RefreshScore(1);
if (hasColision(Piece.Type.NORMAL_FOOD))
{
board.GetFood().SetActiveFood(false); // Seteamos active_food = false, informando que ya no existe comida en el tablero
}
else if (hasColision(Piece.Type.SPECIAL_FOOD))
{
board.GetSpecialFood().SetActiveFood(false); // Seteamos active_food = false, informando que ya no existe comida en el tablero
}
}
// Movemos el snake a la siguiente posición
MoveSnake(increase_snake);
// Comprobamos si existe o debemos asignar comida en el tablero
board.GetFood().UpdateFood(board);
// Comida especial
board.GetSpecialFood().UpdateFood(board);
}
// GetGeneralDirection(): given 2 positions (Vector2Int), return the direction of targetPosition relative to originalPosition
Board.Direction GetGeneralDirection(Vector2Int originalPosition, Vector2Int targetPosition)
{
int originalX = originalPosition.x;
int originalY = originalPosition.y;
int targetX = targetPosition.x;
int targetY = targetPosition.y;
Board.Direction generalDirection = Board.Direction.None;
if (targetX < originalX && targetY > originalY)
{
generalDirection = Board.Direction.NW;
}
else if (targetX == originalX && targetY > originalY)
{
generalDirection = Board.Direction.N;
}
else if (targetX > originalX && targetY > originalY)
{
generalDirection = Board.Direction.NE;
}
else if (targetX > originalX && targetY == originalY)
{
generalDirection = Board.Direction.E;
}
else if (targetX > originalX && targetY < originalY)
{
generalDirection = Board.Direction.SE;
}
else if (targetX == originalX && targetY < originalY)
{
generalDirection = Board.Direction.S;
}
else if (targetX < originalX && targetY < originalY)
{
generalDirection = Board.Direction.SW;
}
else if (targetX < originalX && targetY == originalY)
{
generalDirection = Board.Direction.W;
}
return(generalDirection);
}
private Tuple <bool, Piece> validateJumpMove(
Board.Direction directionOfMove,
Tuple <Player, Piece> oldPieceInfo,
Point newCoordinates)
{
Tuple <Player, Piece> pieceInfo;
Tuple <bool, Piece> rtnInfo = null;
switch (directionOfMove)
{
case Board.Direction.NE: // (0,4) -> (1,3)
pieceInfo = getPieceInfo(newCoordinates.X - 1, newCoordinates.Y - 1);
if (pieceInfo?.Item1.Color != oldPieceInfo?.Item1.Color)
{
rtnInfo = new Tuple <bool, Piece>(true, pieceInfo?.Item2);
}
break;
case Board.Direction.NW: // (7,4) -> (6,3)
pieceInfo = getPieceInfo(newCoordinates.X + 1, newCoordinates.Y - 1);
if (pieceInfo?.Item1.Color != oldPieceInfo?.Item1.Color)
{
rtnInfo = new Tuple <bool, Piece>(true, pieceInfo.Item2);
}
break;
case Board.Direction.SW:
pieceInfo = getPieceInfo(newCoordinates.X + 1, newCoordinates.Y + 1);
if (pieceInfo?.Item1.Color != oldPieceInfo?.Item1.Color)
{
rtnInfo = new Tuple <bool, Piece>(true, pieceInfo.Item2);
}
break;
case Board.Direction.SE:
pieceInfo = getPieceInfo(newCoordinates.X - 1, newCoordinates.Y + 1);
if (pieceInfo?.Item1.Color != oldPieceInfo?.Item1.Color)
{
rtnInfo = new Tuple <bool, Piece>(true, pieceInfo.Item2);
}
break;
}
return(rtnInfo);
}
public bool Move(Board.Direction direction, Func <GameObject, Vector2Int, bool> moveFunction)
{
Debug.Log("Player Try move: " + direction);
Vector2Int newPos;
Direction = direction;
newPos = direction switch
{
Board.Direction.UP => new Vector2Int(BoardPos.x - 1, BoardPos.y),
Board.Direction.DOWN => new Vector2Int(BoardPos.x + 1, BoardPos.y),
Board.Direction.RIGHT => new Vector2Int(BoardPos.x, BoardPos.y + 1),
Board.Direction.LEFT => new Vector2Int(BoardPos.x, BoardPos.y - 1),
_ => throw new Exception("Player move: Bad direction: " + direction),
};
if (moveFunction(Instance, newPos))
{
BoardPos = newPos;
return(true);
}
return(false);
}
//public void InitializeMoving()
//{
//}
public bool MovePiece()//bool isStarting, bool forward, Board.Direction direction, MoveSet moveSet)
{
//if (isStarting) InitializeMoves(direction, moveSet);
PieceMove move = moveSet.GetMove();
Vector3 moveVector = move.ForwardVector();
float friction = currentBoardLoc.GetFriction(transform.position.x, transform.position.z);
moveVector = friction * Speed * Time.deltaTime * moveVector;
float remainingDistance = Vector3.Distance(transform.position, move.GetEndLoc());
if (remainingDistance > moveVector.magnitude)
{
transform.position += moveVector;
}
else
{
//PieceMove nextMove = moveSet.GetNextMove(transform.position, this, currentBoardLoc, pieceDirection);
if (moveSet.HasNextMove())
{
BoardSpace nextSpace = currentBoardLoc.GetSpaceByDirection(pieceDirection);
pieceDirection = move.Direction;
PieceMove nextMove = moveSet.GetNextMove(transform.position, this, currentBoardLoc, pieceDirection);
//currentBoardLoc = nextSpace;
move = nextMove;
float deltaTime = Time.deltaTime * moveVector.magnitude / remainingDistance;
moveVector = move.ForwardVector();
friction = 1; //currentBoardLoc.GetFriction()
moveVector = friction * Speed * deltaTime * moveVector;
}
else
{
transform.position = move.GetEndLoc();
PieceStat = PieceStats.idle;
return(false);
}
}
return(true);
}
private void TakeTurn(Player currentPlayer)
{
Board.Direction direction = Board.Direction.Default;
var command = Console.ReadKey().Key;
switch (command)
{
case ConsoleKey.DownArrow:
direction = Board.Direction.Down;
break;
case ConsoleKey.UpArrow:
direction = Board.Direction.Up;
break;
case ConsoleKey.LeftArrow:
direction = Board.Direction.Left;
break;
case ConsoleKey.RightArrow:
direction = Board.Direction.Right;
break;
case ConsoleKey.Enter:
board.LockPosition(currentPlayer.getSymbol());
if (board.LockPosition(currentPlayer.getSymbol()) == false)
{
Console.WriteLine("That position is alrdy taken!");
TakeTurn(currentPlayer);
}
else
{
currentPlayer.getSymbol();
}
break;
}
board.ChangePosition(direction);
}
//public abstract Vector3 GetEastPoint();
//public abstract Vector3 GetWestPoint();
//public abstract Vector3 GetNorthPoint();
//public abstract Vector3 GetSouthPoint();
public BoardSpace GetSpaceByDirection(Board.Direction Direction)
{
if (Direction == Board.Direction.East)
{
return(PosX);
}
else if (Direction == Board.Direction.North)
{
return(PosZ);
}
else if (Direction == Board.Direction.West)
{
return(NegX);
}
else if (Direction == Board.Direction.South)
{
return(NegZ);
}
else
{
return(null);
}
}
public Vector3 GetPointStartByDirection(Board.Direction enters)
{
if (enters == Board.Direction.East)
{
return(GetWestPoint());
}
else if (enters == Board.Direction.West)
{
return(GetEastPoint());
}
else if (enters == Board.Direction.North)
{
return(GetSouthPoint());
}
else if (enters == Board.Direction.South)
{
return(GetNorthPoint());
}
else
{
return(new Vector3(0, -10, 0));
}
}
public BoardSpace GetNextSpace(BoardSpace space, Board.Direction direction)
{
return(space.GetSpaceByDirection(direction));
}
// GetPawnPositions():
List <Vector2Int> GetPawnPositions(Cell currentCell, Board.Direction frontDirection)
{
Debug.Log("PieceManager::GetPawnPositions");
List <Vector2Int> result = new List <Vector2Int>();
Vector2Int originalPosition = currentCell.GetBoardPosition();
Pawn piece = (Pawn)currentCell.GetCurrentPiece();
// determine front direction adjustment
Vector2Int frontOffset = Vector2Int.zero;
if (frontDirection == Board.Direction.N)
{
frontOffset = Vector2Int.one;
}
else if (frontDirection == Board.Direction.S)
{
frontOffset = new Vector2Int(1, -1);
}
// get top positions
Vector2Int step = Vector2Int.up;
step = Vector2Int.Scale(step, frontOffset);
Vector2Int currentPosition = originalPosition;
for (int stepCount = 0; stepCount < 2; ++stepCount)
{
currentPosition = currentPosition + step;
if (Board.IsOutOfBound(currentPosition) || !mBoard.IsCellEmpty(currentPosition))
{
break;
}
else
{
result.Add(currentPosition);
}
if (!piece.IsFirstMove()) // only 1 step forward if not first move
{
break;
}
}
// get NW position
step = new Vector2Int(-1, 1);
step = Vector2Int.Scale(step, frontOffset);
currentPosition = originalPosition;
currentPosition = currentPosition + step;
if (!Board.IsOutOfBound(currentPosition) && mBoard.IsEnemyInCell(piece, currentPosition))
{
result.Add(currentPosition);
}
// get NE position
step = new Vector2Int(1, 1);
step = Vector2Int.Scale(step, frontOffset);
currentPosition = originalPosition;
currentPosition = currentPosition + step;
if (!Board.IsOutOfBound(currentPosition) && mBoard.IsEnemyInCell(piece, currentPosition))
{
result.Add(currentPosition);
}
return(result);
}
// GetDirectionPositions(): given Direction, current cell, moveStep, return all available positions
List <Vector2Int> GetDirectionPositions(Board.Direction direction, BasePiece.MoveStep moveStep, Cell currentCell, Board.Direction frontDirection)
{
List <Vector2Int> result = new List <Vector2Int>();
Vector2Int currentPosition = currentCell.GetBoardPosition();
BasePiece currentPiece = currentCell.GetCurrentPiece();
// determine direction to step to
Vector2Int offset = Vector2Int.zero;
if (direction == Board.Direction.NW)
{
offset = new Vector2Int(-1, 1);
}
else if (direction == Board.Direction.N)
{
offset = Vector2Int.up;
}
else if (direction == Board.Direction.NE)
{
offset = new Vector2Int(1, 1);
}
else if (direction == Board.Direction.E)
{
offset = Vector2Int.right;
}
else if (direction == Board.Direction.SE)
{
offset = new Vector2Int(1, -1);
}
else if (direction == Board.Direction.S)
{
offset = Vector2Int.down;
}
else if (direction == Board.Direction.SW)
{
offset = new Vector2Int(-1, -1);
}
else if (direction == Board.Direction.W)
{
offset = Vector2Int.left;
}
// determine front direction adjustment
Vector2Int frontOffset = Vector2Int.zero;
if (frontDirection == Board.Direction.N)
{
frontOffset = Vector2Int.one;
}
else if (frontDirection == Board.Direction.S)
{
frontOffset = new Vector2Int(1, -1);
}
offset = Vector2Int.Scale(offset, frontOffset);
// determine how many times we are stepping
int stepNum = 0;
if (moveStep == BasePiece.MoveStep.Single)
{
stepNum = 1;
}
else if (moveStep == BasePiece.MoveStep.Double)
{
stepNum = 2;
}
else if (moveStep == BasePiece.MoveStep.Multiple)
{
stepNum = -1;
}
while (stepNum != 0)
{
Vector2Int nextPosition = currentPosition + offset;
if (!Board.IsOutOfBound(nextPosition) && mBoard.IsTargetCellValid(currentPiece, nextPosition))
{
result.Add(nextPosition);
// cannot advance if path is blocked by another piece
if (!mBoard.IsCellEmpty(nextPosition))
{
break;
}
}
else
{
break;
}
currentPosition = nextPosition;
stepNum -= 1;
}
return(result);
}
public Piece SetDirection(Board.Direction direction)
{
this.direction = direction;
return(this);
}
public void GetMoveFlipped(Board.Direction direction, BoardSpace newSpace)
{
PieceMove move = Moves[movesIndex];
initializeMove(move.myPiece.transform.position, move.myPiece, newSpace, direction, movesIndex);
}
private void initializeMove(Vector3 StartLoc, BoardPiece cat, BoardSpace moveSpace, Board.Direction direction, int moveIndex)
{
bool lastMove = Moves.Count - 1 == moveIndex || Moves[moveIndex + 1].GetMyType() != "Walk";
Moves[moveIndex].InitializeMove(StartLoc, cat, moveSpace, direction, lastMove);
}
public void InitializeMoves(Board.Direction direction, MoveSet moveSet)
{
this.moveSet = moveSet;
moveSet.StartMoves(this, currentBoardLoc, direction);
}
private MoveInfo getMoveInfo(Piece piece, Point newCoordinates)
{
if (piece == null)
{
throw new ArgumentNullException();
}
if (newCoordinates == null)
{
throw new ArgumentNullException();
}
var rtnMove = new MoveInfo();
if (newCoordinates.X >= Board.GRID_SIZE || newCoordinates.Y >= Board.GRID_SIZE ||
newCoordinates.X < 0 || newCoordinates.Y < 0)
{
return(rtnMove);
}
int dX = newCoordinates.X - piece.Location.X,
dY = newCoordinates.Y - piece.Location.Y;
Board.Direction directionOfMove = Board.getMoveDirection(dY, dX);
bool isJumpMove = Math.Abs(dX) == 2 && Math.Abs(dY) == 2;
bool isMove = Math.Abs(dX) == 1 && Math.Abs(dY) == 1;
Tuple <Player, Piece> pieceInfo = getPieceInfo(newCoordinates.X, newCoordinates.Y);
Tuple <Player, Piece> oldPieceInfo = getPieceInfo(piece.Location.X, piece.Location.Y);
if (pieceInfo == null)
{
if (isMove)
{
if (oldPieceInfo.Item1.Color == Player.EnumColor.White)
{
if (piece.TypeOfPiece == Piece.PieceType.Man)
{
rtnMove.isValidMove = directionOfMove == Board.Direction.SE || directionOfMove == Board.Direction.SW;
}
}
else
{
if (piece.TypeOfPiece == Piece.PieceType.Man)
{
rtnMove.isValidMove = directionOfMove == Board.Direction.NE || directionOfMove == Board.Direction.NW;
}
}
}
else if (isJumpMove)
{
bool validDirection = true;
if (oldPieceInfo.Item1.Color == Player.EnumColor.White)
{
if (piece.TypeOfPiece == Piece.PieceType.Man)
{
validDirection = directionOfMove == Board.Direction.SE || directionOfMove == Board.Direction.SW;
}
}
else
{
if (piece.TypeOfPiece == Piece.PieceType.Man)
{
validDirection = directionOfMove == Board.Direction.NE || directionOfMove == Board.Direction.NW;
}
}
if (validDirection)
{
Tuple <bool, Piece> validate = validateJumpMove(directionOfMove, oldPieceInfo, newCoordinates);
rtnMove.isValidJumpMove = validate.Item1;
rtnMove.JumpedPiece = validate.Item2;
}
}
}
return(rtnMove);
}
// GetPathPositions(): given 2 positiosn (Vector2Int), return list of positions
// .. maybe should be in PieceManager...
List <Vector2Int> GetPathPositions(Vector2Int originalPosition, Vector2Int targetPosition)
{
Debug.Log("PieceManager::GetPathPositions()");
List <Vector2Int> results = new List <Vector2Int>();
int originalX = originalPosition.x;
int originalY = originalPosition.y;
int targetX = targetPosition.x;
int targetY = targetPosition.y;
Board.Direction generalDirection = GetGeneralDirection(originalPosition, targetPosition);
Debug.Log("general direction is: " + generalDirection);
// determine if it is a line
Vector2Int offset = Vector2Int.zero;
if (generalDirection == Board.Direction.N)
{
offset = Vector2Int.up;
}
else if (generalDirection == Board.Direction.E)
{
offset = Vector2Int.right;
}
else if (generalDirection == Board.Direction.S)
{
offset = Vector2Int.down;
}
else if (generalDirection == Board.Direction.W)
{
offset = Vector2Int.left;
}
else if (generalDirection == Board.Direction.NE)
{
if (targetX - originalX == targetY - originalY)
{
Debug.Log("is a line!");
offset = new Vector2Int(1, 1);
}
}
else if (generalDirection == Board.Direction.SE)
{
if (targetX - originalX == -(targetY - originalY))
{
Debug.Log("is a line!");
offset = new Vector2Int(1, -1);
}
}
else if (generalDirection == Board.Direction.SW)
{
if (targetX - originalX == targetY - originalY)
{
Debug.Log("is a line!");
offset = new Vector2Int(-1, -1);
}
}
else if (generalDirection == Board.Direction.NW)
{
if (-(targetX - originalX) == targetY - originalY)
{
Debug.Log("is a line");
offset = new Vector2Int(-1, 1);
}
}
// construct list
Vector2Int currentPosition = originalPosition;
while (true)
{
results.Add(currentPosition);
// reach target
if (currentPosition == targetPosition)
{
break;
}
// keep stepping
Vector2Int nextPosition = currentPosition + offset;
if (nextPosition == currentPosition)
{
Debug.Log("not a line!");
currentPosition = targetPosition;
}
else
{
currentPosition = nextPosition;
}
}
return(results);
}
/// <summary>
/// Initialize MoveSet
/// </summary>
/// <returns><c>true</c>, if piece was moved, <c>false</c> otherwise.</returns>
/// <param name="moveSet">Move set.</param>
/// <param name="direction">Direction.</param>
///
public bool MovePiece(MoveSet moveSet, Board.Direction direction)
{
InitializeMoves(direction, moveSet);
PieceStat = PieceStats.isMoving;
return(MovePiece());
}
