public void AddPiece(GameObject prefab, Player player, int col, int row)
{
Debug.Log("Add Piece");
Debug.Log(col.ToString());
Debug.Log(row.ToString());
GameObject pieceObject = board.AddPiece(prefab, col, row);
player.pieces.Add(pieceObject);
pieces[MapValue(-20, 20, 0, 4, col), MapValue(-20, 20, 0, 4, row)] = pieceObject;
}
public bool TapAction(int x, int y)
{
//! Here we make sure that there's no piece here already before accepting the tap
//! If you wanted to expand the AGD system to allow for tapping pieces, you'd change this
if (state.Value(x, y) == 0)
{
//! By default, tapping an empty space spawns our piece in
state.Set(x, y, Player.CURRENT);
//! If we're in interactive mode, we notify the board that we've placed a piece
if (interactiveMode)
{
playableGame.AddPiece(x, y, CurrentPlayer() - 1);
}
//! Automatically end the turn after a player has placed a piece
//! Again, if you wanted to allow multiple actions, you'd change this.
EndTurn();
return(true);
}
else
{
return(false);
}
}
int MiniMax(Move[] allPossibleWhiteMoves, Move[] allPossibleBlackMoves, int depth, bool maximizingPlayer)
{
int currentState;
if (maximizingPlayer)
{
if (boardManager.CalculateWhiteCheck() && allPossibleWhiteMoves.Length == 0)
{
currentState = int.MinValue;
return(currentState);
}
else if (allPossibleWhiteMoves.Length == 0)
{
currentState = 0;
return(currentState);
}
}
else
{
if (boardManager.CalculateBlackCheck() && allPossibleBlackMoves.Length == 0)
{
currentState = int.MaxValue;
return(currentState);
}
else if (allPossibleBlackMoves.Length == 0)
{
currentState = 0;
return(currentState);
}
}
if (depth == 0)
{
currentState = CalculateGameState(boardManager.allWhitePieces.ToArray(), boardManager.allBlackPieces.ToArray());
return(currentState);
}
if (maximizingPlayer)
{
bool kingMovement = boardManager.whiteKingHasMoved;
ChessPiece leftWhiteRook = boardManager.ChessPieces [0, 0];
ChessPiece rightWhiteRook = boardManager.ChessPieces [7, 0];
int maxState = int.MinValue;
for (int i = allPossibleWhiteMoves.Length - 1; i >= 0; i--)
{
ChessPiece pieceToMove = allPossibleWhiteMoves [i].pieceToMove;
ChessPiece targetPiece = allPossibleWhiteMoves [i].targetPiece;
if (targetPiece != null)
{
boardManager.CaptureSimulation(targetPiece);
}
if (pieceToMove.GetType() == typeof(King))
{
boardManager.whiteKingHasMoved = true;
if (allPossibleWhiteMoves [i].targetX == allPossibleWhiteMoves [i].currentX - 2)
{
boardManager.MoveInGame(3, 0, leftWhiteRook);
}
else if (allPossibleWhiteMoves [i].targetX == allPossibleWhiteMoves [i].currentX + 2)
{
boardManager.MoveInGame(5, 0, rightWhiteRook);
}
}
boardManager.MoveInGame(allPossibleWhiteMoves [i].targetX, allPossibleWhiteMoves [i].targetY, pieceToMove);
currentState = MiniMax(null, boardManager.CalculateNextBlackMoves(), depth - 1, false);
Evaluation evaluation = new Evaluation(allPossibleWhiteMoves [i], currentState);
if (depth == numberOfMovesToLookAhead)
{
evaluations.Add(evaluation);
}
if (currentState > maxState)
{
maxState = currentState;
}
boardManager.RevertInGame(allPossibleWhiteMoves [i].currentX, allPossibleWhiteMoves [i].currentY, allPossibleWhiteMoves [i].targetX, allPossibleWhiteMoves [i].targetY, targetPiece, pieceToMove);
if (pieceToMove.GetType() == typeof(King))
{
boardManager.whiteKingHasMoved = kingMovement;
if (allPossibleWhiteMoves [i].targetX == allPossibleWhiteMoves [i].currentX - 2)
{
boardManager.RevertInGame(0, 0, 3, 0, null, leftWhiteRook);
}
else if (allPossibleWhiteMoves [i].targetX == allPossibleWhiteMoves [i].currentX + 2)
{
boardManager.RevertInGame(7, 0, 5, 0, null, rightWhiteRook);
}
}
if (targetPiece != null)
{
boardManager.AddPiece(targetPiece, allPossibleWhiteMoves [i].targetX, allPossibleWhiteMoves [i].targetY);
}
}
return(maxState);
}
else
{
bool kingMovement = boardManager.blackKingHasMoved;
ChessPiece leftBlackRook = boardManager.ChessPieces [0, 7];
ChessPiece rightBlackRook = boardManager.ChessPieces [7, 7];
int minState = int.MaxValue;
for (int i = allPossibleBlackMoves.Length - 1; i >= 0; i--)
{
ChessPiece pieceToMove = allPossibleBlackMoves [i].pieceToMove;
ChessPiece targetPiece = allPossibleBlackMoves [i].targetPiece;
if (targetPiece != null)
{
boardManager.CaptureSimulation(targetPiece);
}
if (pieceToMove.GetType() == typeof(King))
{
boardManager.blackKingHasMoved = true;
if (allPossibleBlackMoves [i].targetX == allPossibleBlackMoves [i].currentX - 2)
{
boardManager.MoveInGame(3, 7, leftBlackRook);
}
else if (allPossibleBlackMoves [i].targetX == allPossibleBlackMoves [i].currentX + 2)
{
boardManager.MoveInGame(5, 7, rightBlackRook);
}
}
boardManager.MoveInGame(allPossibleBlackMoves [i].targetX, allPossibleBlackMoves [i].targetY, pieceToMove);
currentState = MiniMax(boardManager.CalculateNextWhiteMoves(), null, depth - 1, true);
Evaluation evaluation = new Evaluation(allPossibleBlackMoves [i], currentState);
if (depth == numberOfMovesToLookAhead)
{
evaluations.Add(evaluation);
}
if (currentState < minState)
{
minState = currentState;
}
boardManager.RevertInGame(allPossibleBlackMoves [i].currentX, allPossibleBlackMoves [i].currentY, allPossibleBlackMoves [i].targetX, allPossibleBlackMoves [i].targetY, targetPiece, pieceToMove);
if (pieceToMove.GetType() == typeof(King))
{
boardManager.blackKingHasMoved = kingMovement;
if (allPossibleBlackMoves [i].targetX == allPossibleBlackMoves [i].currentX - 2)
{
boardManager.RevertInGame(0, 7, 3, 7, null, leftBlackRook);
}
else if (allPossibleBlackMoves [i].targetX == allPossibleBlackMoves [i].currentX + 2)
{
boardManager.RevertInGame(7, 7, 5, 7, null, rightBlackRook);
}
}
if (targetPiece != null)
{
boardManager.AddPiece(targetPiece, allPossibleBlackMoves [i].targetX, allPossibleBlackMoves [i].targetY);
}
}
return(minState);
}
}
void TouchInput()
{
foreach (Touch touch in Input.touches)
{
if (touch.phase == TouchPhase.Began)
{
if (selectCooldown > 0) //if it was touched before the cooldown was ended
{
selectCooldown = Mathf.Min(selectCooldown * 1.5f, selectDelay);
}
if (selectCooldown <= 0 && Physics.Raycast(Camera.main.ScreenPointToRay(touch.position), out hit, raycastHit))
{
GameObject gHit = hit.collider.gameObject;
if (gHit.tag.Equals("Piece") || gHit.tag.Equals("Moving")) //if it is a piece on the board
{
if (selected == null) //if nothing is selected
{
selectedRenderer = gHit.GetComponentInChildren <Renderer>();
prevMaterial = selectedRenderer.material;
selectedRenderer.material = selectedMaterial;
selected = gHit;
selectCooldown = selectDelay;
}
else if (!gHit.Equals(selected)) //if something else is selected
{
if (Deselect())
{
selectedRenderer = gHit.GetComponentInChildren <Renderer>();
prevMaterial = selectedRenderer.material;
selectedRenderer.material = selectedMaterial;
selected = gHit;
selectCooldown = selectDelay;
}
}
else if (gHit.Equals(selected)) //if the selected piece is selected
{
Deselect();
}
}
else if (gHit.tag.Equals("Tile") && selected != null) //after it has selected a piece, if it is selecting a tile
{
if (shelfPlace)
{
GameObject tmp = Instantiate(selected, transform);
tmp.transform.localPosition = gHit.transform.parent.localPosition;
boardManager.AddPiece(tmp);
Deselect();
}
else
{
PieceMover tmp;
if (selected.tag.Equals("Moving")) //if it is already moving
{
tmp = selected.GetComponent <PieceMover>();
}
else
{
tmp = selected.AddComponent <PieceMover>();
}
tmp.MoveTo(gHit.transform.parent.localPosition);
Deselect();
}
}
else if (selectCooldown <= 0) //if something not part of the board was hit
{
Deselect();
}
}
else if (selectCooldown <= 0) //if nothing was hit
{
Deselect();
}
} //touchphase began
break;
}
}
