public bool KingIsChecked(GameStateEntity state, Color kingColor)
{
Console.WriteLine("Active player: " + state.ActivePlayer);
Console.WriteLine("King color: " + kingColor);
var board = state.GameBoard;
var kingPos = Utilities.FindKing(state, kingColor);
var opponentColor = kingColor == Color.White ? Color.Black : Color.White;
for (int y = 0; y < board.Width(); y++)
{
for (int x = 0; x < board.Width(); x++)
{
var piece = board.GetPieceAt(new Point(x, y));
if (piece.Color == opponentColor)
{
GameMoveEntity moveToKing = new GameMoveEntity(piece.Type, new Point(x, y), kingPos, piece.Color);
if (rules.All(rule => rule.IsValid(moveToKing, state)))
{
return(true);
}
}
}
}
return(false);
}
private GameStateEntity ExecuteMove(GameMoveEntity movement, GameStateEntity state)
{
bool hasMoved = true;
var movedPiece = state.GameBoard.GetPieceAt(movement.CurrentPos);
var target = state.GameBoard.GetPieceAt(movement.RequestedPos);
var opponentColor = state.ActivePlayer == Color.White ? Color.Black : Color.White;
if (Castling(movedPiece, target))
{
state = PerformCastling(movement, state);
}
else
{
state.GameBoard.PlacePieceAt(movement.CurrentPos, new GamePiece(PieceType.None, Color.None));
state.GameBoard.PlacePieceAt(movement.RequestedPos, new GamePiece(movement.Type, movement.Color, hasMoved));
}
if (ruleBook.KingIsChecked(state, opponentColor))
{
if (Checkmate(state))
{
state.Winner = state.ActivePlayer;
}
state.KingIsChecked = true;
return(state);
}
state.KingIsChecked = false;
return(state);
}
public void SaveState(GameStateEntity _state)
{
try
{
XElement board = new XElement("board");
for (int y = 0; y < _state.GameBoard.Width(); y++)
{
for (int x = 0; x < _state.GameBoard.Width(); x++)
{
var piece = _state.GameBoard.GetPieceAt(new Point(x, y));
board.Add(new XElement("GamePiece",
new XElement("type", piece.Type.ToString()),
new XElement("color", piece.Color.ToString())));
}
}
XDocument database = new XDocument(
new XElement("root",
board,
new XElement("active_player", _state.ActivePlayer),
new XElement("pawn_is_promoted", _state.PawnIsPromoted),
new XElement("winner", _state.Winner),
new XElement("king_is_checked", _state.KingIsChecked))
);
database.Save(DatabasePath);
}
catch (Exception)
{
throw new DatabaseSaveFailureException("Failed to save to datbase");
}
}
public static bool IsDiagonal(GameMoveEntity movement, GameStateEntity state)
{
int deltaX = Math.Abs(movement.RequestedPos.X - movement.CurrentPos.X);
int deltaY = Math.Abs(movement.RequestedPos.Y - movement.CurrentPos.Y);
return(deltaX == deltaY);
}
private void Awake() {
SceneManager.sceneLoaded += OnSceneLoaded;
gameOverCanvas.enabled = false;
var contexts = Contexts.sharedInstance;
if (!contexts.gameState.isGameState) {
_attackEntity = contexts.input.CreateEntity();
_attackEntity.isAttackInput = true;
_switchEntity = contexts.input.CreateEntity();
_switchEntity.isSwitchInput = true;
_gameStateEntity = contexts.gameState.CreateEntity();
_gameStateEntity.isGameState = true;
_gameStateEntity.AddGameOverScreen(gameOverCanvas);
_gameStateEntity.AddGameOverText(gameOverText);
}
_systems = new Systems();
_systems.Add(new InputSystem(contexts));
_systems.Add(new PrefabInstantiateSystem(contexts));
_systems.Add(new TransformApplySystem(contexts));
_systems.Add(new AttackSystem(contexts));
_systems.Add(new ComputeDamageSystem(contexts));
_systems.Add(new ApplyDamageSystem(contexts));
_systems.Add(new RunningSystem(contexts));
_systems.Add(new EndGameSystem(contexts));
_systems.Add(new AITurnSystem(contexts));
_systems.Add(new ViewDestroySystem(contexts));
_systems.Initialize();
}
private void DrawBoard(GameStateEntity state)
{
var converter = new BrushConverter();
var blackBrush = (Brush)converter.ConvertFromString("#FF480000");
var whiteBrush = (Brush)converter.ConvertFromString("#FFF9D093");
for (int y = 0; y < state.GameBoard.Width(); y++)
{
for (int x = 0; x < state.GameBoard.Width(); x++)
{
Rectangle rect = new Rectangle();
rect.Height = SQUARE_SIZE;
rect.Width = SQUARE_SIZE;
rect.Name = "rect" + x.ToString() + y.ToString();
if ((x + y) % 2 == 0)
{
rect.Fill = blackBrush;
}
else
{
rect.Fill = whiteBrush;
}
this.GameBoard.Children.Add(rect);
Grid.SetColumn(rect, x);
Grid.SetRow(rect, y);
}
}
}
public static bool CheckedAfterCastling(GameStateEntity state, Color kingColor)
{
var board = state.GameBoard;
Point king = FindKing(state, kingColor);
for (int y = 0; y < board.Width(); y++)
{
for (int x = 0; x < board.Width(); x++)
{
var type = board.GetPieceAt(new Point(x, y)).Type;
var color = board.GetPieceAt(new Point(x, y)).Color;
if ((type == PieceType.Bishop || type == PieceType.Queen) && color != state.ActivePlayer)
{
var potentialThreat = new GameMoveEntity(type, new Point(x, y), new Point(king.X, king.Y), state.ActivePlayer);
if (Utilities.IsDiagonal(potentialThreat, state) && Utilities.PathIsClear(potentialThreat, board))
{
return(true);
}
}
if ((type == PieceType.Rook || type == PieceType.Queen) && color != state.ActivePlayer)
{
Console.WriteLine("INNE I ROOK");
var potentialThreat = new GameMoveEntity(type, new Point(x, y), new Point(king.X, king.Y), state.ActivePlayer);
if (Utilities.IsLinear(potentialThreat, state) && Utilities.PathIsClear(potentialThreat, board))
{
return(true);
}
}
}
}
return(false);
}
private GameMoveEntity SetColorAndType(GameMoveEntity movement, GameStateEntity state)
{
movement.Color = state.GameBoard.GetPieceAt(movement.CurrentPos).Color;
movement.Type = state.GameBoard.GetPieceAt(movement.CurrentPos).Type;
return(movement);
}
private bool CastleMovement(GameMoveEntity movement, GameStateEntity state)
{
var king = state.GameBoard.GetPieceAt(movement.CurrentPos);
var rook = state.GameBoard.GetPieceAt(movement.RequestedPos);
Point newKingPos = movement.RequestedPos;
if (movement.RequestedPos.X == 0 && movement.RequestedPos.Y == 0)
{
newKingPos = new Point(1, 0);
}
else if (movement.RequestedPos.X == 7 && movement.RequestedPos.Y == 0)
{
newKingPos = new Point(5, 0);
}
else if (movement.RequestedPos.X == 0 && movement.RequestedPos.Y == 7)
{
newKingPos = new Point(2, 7);
}
else if (movement.RequestedPos.X == 7 && movement.RequestedPos.Y == 7)
{
newKingPos = new Point(6, 7);
}
GameStateEntity mockState = state.Clone();
mockState.GameBoard.PlacePieceAt(newKingPos, mockState.GameBoard.GetPieceAt(movement.CurrentPos));
mockState.GameBoard.PlacePieceAt(movement.CurrentPos, new GamePiece(PieceType.None, Color.None));
return(!king.HasMoved &&
!rook.HasMoved &&
rook.Type == PieceType.Rook &&
Utilities.PathIsClear(movement, state.GameBoard) &&
Utilities.StepOnOwnPiece(movement, state) &&
!Utilities.CheckedAfterCastling(mockState, mockState.ActivePlayer));
}
public void OnAnyCurrentLevel(GameStateEntity entity, int value)
{
if (_titleText == null)
{
throw new ArgumentNullException("_titleText");
}
_titleText.text = $"Stage {value}\nContinue?";
}
public void OnAnyCurrentLevel(GameStateEntity entity, int value)
{
if (_levelNum == null)
{
throw new ArgumentNullException("Level num label is missing!");
}
_levelNum.text = "Level " + value.ToString();
}
public bool IsValid(GameMoveEntity movement, GameStateEntity state)
{
if (!movement.Type.Equals(PieceType.King))
{
return(true);
}
return(CastleMovement(movement, state) || NormalMovement(movement, state));
}
private void DrawPromotionOptions(List <GamePiece> options, GameStateEntity state)
{
for (int i = 0; i < options.Count; i++)
{
var texture = textures.GetTexture(options[i]);
this.promotionGrid.Children.Add(texture);
Grid.SetColumn(texture, i);
Grid.SetRow(texture, 0);
}
}
private bool Checkmate(GameStateEntity state)
{
Color enemyColor = state.ActivePlayer == Color.White ? Color.Black : Color.White;
Point kingPos = Utilities.FindKing(state, enemyColor);
List <Point> aggressors = FindPiecesThatReachTarget(state, kingPos, state.ActivePlayer);
var clonedState = state.Clone();
clonedState.ActivePlayer = enemyColor;
return(!CanMoveKing(clonedState) && !CanCaptureAggressor(clonedState, aggressors) && !CanBlockPath(clonedState, aggressors));
}
public bool IsValid(GameMoveEntity movement, GameStateEntity state)
{
if (!movement.Type.Equals(PieceType.Bishop))
{
return(true);
}
if (Utilities.StepOnOwnPiece(movement, state))
{
return(false);
}
return(Utilities.IsDiagonal(movement, state) && Utilities.PathIsClear(movement, state.GameBoard));
}
private bool NormalMovement(GameMoveEntity movement, GameStateEntity state)
{
if (Utilities.StepOnOwnPiece(movement, state))
{
return(false);
}
int deltaX = Math.Abs(movement.RequestedPos.X - movement.CurrentPos.X);
int deltaY = Math.Abs(movement.RequestedPos.Y - movement.CurrentPos.Y);
return(deltaX < 2 && deltaY < 2);
}
public void OnScore(GameStateEntity entity, int value)
{
if (value == _lastValue)
{
return;
}
var difference = value - _lastValue;
_label.text = difference.ToString();
_animator.SetTrigger(_triggerHash);
_lastValue = value;
}
public bool IsValid(GameMoveEntity movement, GameStateEntity state)
{
if (movement.Type != PieceType.Pawn)
{
return(true);
}
if (Utilities.StepOnOwnPiece(movement, state))
{
return(false);
}
return(NormalMovement(movement, state) ||
ChargeMovement(movement, state) ||
AttackMovement(movement, state));
}
private void Draw(GameStateEntity state)
{
if (state.PawnIsPromoted)
{
DrawPromotion(state);
}
else
{
this.GameBoard.Children.Clear();
DrawBoard(state);
DrawGamePieces(state);
DrawInvisibleButtons(state);
DrawLabels(state);
}
}
private bool AttackMovement(GameMoveEntity movement, GameStateEntity state)
{
int deltaX = Math.Abs(movement.RequestedPos.X - movement.CurrentPos.X);
int deltaY = movement.RequestedPos.Y - movement.CurrentPos.Y;
var target = state.GameBoard.GetPieceAt(movement.RequestedPos);
if (movement.Color == Color.White)
{
return(deltaX == 1 && deltaY == -1 && target.Color == Color.Black);
}
else
{
return(deltaX == 1 && deltaY == 1 && target.Color == Color.White);
}
}
public void OnAnyCurrentLevel(GameStateEntity entity, int value)
{
if (_label01 == null)
{
throw new ArgumentNullException("Label 01 is missing!");
}
if (_label02 == null)
{
throw new ArgumentNullException("Label 02 is missing!");
}
_label01.text = value.ToString();
_label02.text = (value + 1).ToString();
}
private GameStateEntity CheckForPromotion(GameMoveEntity movement, GameStateEntity state)
{
if (movement.Type == PieceType.Pawn)
{
if (state.ActivePlayer == Color.White)
{
state.PawnIsPromoted = movement.RequestedPos.Y == 0;
}
else
{
state.PawnIsPromoted = movement.RequestedPos.Y == state.GameBoard.Width() - 1;
}
}
return(state);
}
private bool CanCaptureAggressor(GameStateEntity state, List <Point> aggressors)
{
if (aggressors.Count() > 1)
{
return(false);
}
Point aggressor = aggressors[0];
if (FindPiecesThatReachTarget(state, aggressor, state.ActivePlayer).Count() > 0)
{
return(true);
}
return(false);
}
public bool IsValid(GameMoveEntity movement, GameStateEntity state)
{
if (!movement.Type.Equals(PieceType.Knight))
{
return(true);
}
if (Utilities.StepOnOwnPiece(movement, state))
{
return(false);
}
int deltaX = Math.Abs(movement.RequestedPos.X - movement.CurrentPos.X);
int deltaY = Math.Abs(movement.RequestedPos.Y - movement.CurrentPos.Y);
return(deltaX == 2 && deltaY == 1 || deltaX == 1 && deltaY == 2);
}
/// <summary>
/// Changes the game state
/// </summary>
/// <param name="gameState">The state to transition to</param>
internal void ChangeState(GameState gameState)
{
if (_gameStateEntity != null)
{
_gameStateEntity.Dispose();
_gameStateEntity = null;
}
_previousGameState = _currentGameState;
_currentGameState = gameState;
stateText.text = gameState.ToString();
_gameStateEntity = _gameStateFactory.CreateState(gameState);
_gameStateEntity.Start();
}
private void DrawGamePieces(GameStateEntity state)
{
for (int y = 0; y < state.GameBoard.Width(); y++)
{
for (int x = 0; x < state.GameBoard.Width(); x++)
{
var piece = state.GameBoard.GetPieceAt(new Entities.Point(x, y));
if (piece.Type != PieceType.None)
{
var texture = textures.GetTexture(piece);
this.GameBoard.Children.Add(texture);
Grid.SetColumn(texture, x);
Grid.SetRow(texture, y);
}
}
}
}
public bool MoveIsValid(GameMoveEntity movement, GameStateEntity state)
{
bool moveIsAllowed = rules.All(rule => rule.IsValid(movement, state));
bool kingIsChecked = false;
if (moveIsAllowed)
{
var clonedState = state.Clone();
clonedState.GameBoard.PlacePieceAt(movement.RequestedPos, new GamePiece(movement.Type, movement.Color));
clonedState.GameBoard.PlacePieceAt(movement.CurrentPos, new GamePiece(PieceType.None, Color.None));
clonedState.ActivePlayer = state.ActivePlayer == Color.White ? Color.Black : Color.White;
kingIsChecked = KingIsChecked(clonedState, state.ActivePlayer);
}
return(moveIsAllowed && !kingIsChecked);
}
private List <Point> FindBlockPositions(GameStateEntity state, Point king, Point aggressor)
{
int deltaX = king.X - aggressor.X;
int deltaY = king.Y - aggressor.Y;
int stepX = deltaX == 0 ? 0 : deltaX / System.Math.Abs(deltaX);
int stepY = deltaY == 0 ? 0 : deltaY / System.Math.Abs(deltaY);
var board = state.GameBoard;
var blockPositions = new List <Point>();
for (int i = 1; i < Math.Max(Math.Abs(deltaX), Math.Abs(deltaY)); i++)
{
Point position = new Point(king.X + i * stepX, king.Y + i * stepY);
blockPositions.Add(position);
}
return(blockPositions);
}
private bool CanMoveKing(GameStateEntity state)
{
List <GameMoveEntity> positions = new List <GameMoveEntity>();
var king = Utilities.FindKing(state, state.ActivePlayer);
for (int y = king.Y - 1; y <= king.Y + 1; y++)
{
for (int x = king.X - 1; x <= king.X + 1; x++)
{
if (x >= 0 && y >= 0 && x < 8 && y < 8)
{
positions.Add(new GameMoveEntity(PieceType.King, king, new Point(x, y), state.ActivePlayer));
}
}
}
return(positions.Any(pos => ruleBook.MoveIsValid(pos, state)));
}
private void DrawPromotion(GameStateEntity state)
{
DeactivateBoard(state);
infoLabel.Content = "Your pawn has been promoted.\nPlease select a piece";
var promotingPlayer = state.ActivePlayer == Entities.Color.White ? Entities.Color.Black : Entities.Color.White;
var options = new List <GamePiece>
{
new GamePiece(PieceType.Queen, promotingPlayer),
new GamePiece(PieceType.Rook, promotingPlayer),
new GamePiece(PieceType.Bishop, promotingPlayer),
new GamePiece(PieceType.Knight, promotingPlayer)
};
DrawPromotionOptions(options, state);
DrawPromotionButtons(options);
}
