workHEADmaster

6 files changed, 436 insertions, 287 deletions

diff --git a/Pieces/Bishop.cs b/Pieces/Bishop.cs
index 10d1537..6e509ca 100644
--- a/Pieces/Bishop.cs
+++ b/Pieces/Bishop.cs
@@ -1,42 +1,42 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Chess.Pieces
-{
-    class Bishop : ChessPiece
-    {
-        public Bishop(bool isWhite) : base(isWhite)
-        {
-            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_bishop_png_shadow_256px : Chess.Properties.Resources.w_bishop_png_shadow_256px);
-        }
-
-        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)
-        {
-            MoveCheckResult result;
-
-            result = CanMoveDownLeft(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveDownRight(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveUpLeft(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveUpRight(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            return false;
-        }
-
-       
-    }
-}
+using System;

+using System.Collections.Generic;

+using System.Drawing;

+using System.Linq;

+using System.Text;

+using System.Threading.Tasks;

+

+namespace Chess.Pieces

+{

+    class Bishop : ChessPiece

+    {

+        public Bishop(bool isWhite) : base(isWhite)

+        {

+            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_bishop_png_shadow_256px : Chess.Properties.Resources.w_bishop_png_shadow_256px);

+        }

+

+        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)

+        {

+            MoveCheckResult result;

+

+            result = CanMoveDownLeft(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveDownRight(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveUpLeft(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveUpRight(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            return false;

+        }

+

+       

+    }

+}

diff --git a/Pieces/King.cs b/Pieces/King.cs
index 945c476..0a98597 100644
--- a/Pieces/King.cs
+++ b/Pieces/King.cs
@@ -1,58 +1,123 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Chess.Pieces
-{
-    class King : ChessPiece
-    {
-        public King(bool isWhite) : base(isWhite)
-        {
-            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_king_png_shadow_256px : Chess.Properties.Resources.w_king_png_shadow_256px);
-        }
-
-        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)
-        {
-            MoveCheckResult result;
-
-            result = CanMoveDown(board, currentTile, destinationTile, 1);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveUp(board, currentTile, destinationTile, 1);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveLeft(board, currentTile, destinationTile, 1);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveRight(board, currentTile, destinationTile, 1);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            // diagonal 
-
-            result = CanMoveDownLeft(board, currentTile, destinationTile, 1);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveDownRight(board, currentTile, destinationTile, 1);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveUpLeft(board, currentTile, destinationTile, 1);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveUpRight(board, currentTile, destinationTile, 1);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            return false;
-        }
-    }
-}
+using System;

+using System.Collections.Generic;

+using System.Drawing;

+using System.Linq;

+using System.Text;

+using System.Threading.Tasks;

+

+namespace Chess.Pieces

+{

+    class King : ChessPiece

+    {

+        bool isInInitialPosition = true;

+

+        public King(bool isWhite) : base(isWhite)

+        {

+            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_king_png_shadow_256px : Chess.Properties.Resources.w_king_png_shadow_256px);

+        }

+

+        public override void PostMovementEvent(BoardTile tile)

+        {

+            isInInitialPosition = false;

+

+            base.PostMovementEvent(tile);

+        }

+

+        internal override MoveCheckResult CanMoveLeft(ChessBoard board, BoardTile currentTile, BoardTile destinationTile, int count = 8)

+        {

+            MoveCheckResult result = base.CanMoveLeft(board, currentTile, destinationTile, count);

+

+            // Check for legal castling move

+            if (isInInitialPosition)

+            {

+                var rooks = board.TilesByPieceType(typeof(Rook), this.IsWhite);

+

+                foreach(var rook in rooks)

+                {

+                    if (rook != destinationTile) continue;

+

+                    if (rook.OccupyingPiece is Rook piece)

+                    {

+                        if (piece.IsInInitialPosition)

+                        {

+                            if (rook.X == 0)

+                            {

+                                // check right path

+                                if (board.Tiles[currentTile.Y, currentTile.X - 1].OccupyingPiece == null && rook.CanMoveTo(board, board.Tiles[currentTile.Y, currentTile.X - 1]))

+                                {

+                                    result = MoveCheckResult.CanMove;

+                                }

+                            }

+                            else if (rook.X == 7)

+                            {

+                                // check left path

+                                if (board.Tiles[currentTile.Y, currentTile.X + 1].OccupyingPiece == null && rook.CanMoveTo(board, board.Tiles[currentTile.Y, currentTile.X + 1]))

+                                {

+                                    result = MoveCheckResult.CanMove;

+                                }

+                            }

+                        }

+                    }

+                }

+

+            }

+

+            return result;

+        }

+

+        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)

+        {

+            MoveCheckResult result;

+

+            result = CanMoveDown(board, currentTile, destinationTile, 1);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveUp(board, currentTile, destinationTile, 1);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveLeft(board, currentTile, destinationTile, 1);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveRight(board, currentTile, destinationTile, 1);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            // diagonal 

+

+            result = CanMoveDownLeft(board, currentTile, destinationTile, 1);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveDownRight(board, currentTile, destinationTile, 1);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveUpLeft(board, currentTile, destinationTile, 1);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveUpRight(board, currentTile, destinationTile, 1);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            return false;

+        }

+

+        internal BoardTile GetCastleLocation(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)

+        {

+            if (destinationTile.X < currentTile.X)

+            {

+                return board.Tiles[currentTile.Y, currentTile.X - 2];

+            }

+            else if (destinationTile.X > currentTile.X)

+            {

+                return board.Tiles[currentTile.Y, currentTile.X + 2];

+            }

+

+            return destinationTile;

+        }

+    }

+}

diff --git a/Pieces/Knight.cs b/Pieces/Knight.cs
index 5a0aea7..cd6db72 100644
--- a/Pieces/Knight.cs
+++ b/Pieces/Knight.cs
@@ -1,46 +1,46 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Chess.Pieces
-{
-    class Knight : ChessPiece
-    {
-        public Knight(bool isWhite) : base(isWhite)
-        {
-            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_knight_png_shadow_256px : Chess.Properties.Resources.w_knight_png_shadow_256px);
-        }
-
-        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)
-        {
-            Point[] pointsToCheck = {
-                new Point(currentTile.X - 2, currentTile.Y - 1),
-                new Point(currentTile.X - 2, currentTile.Y + 1),
-
-                new Point(currentTile.X + 2, currentTile.Y - 1),
-                new Point(currentTile.X + 2, currentTile.Y + 1),
-
-                new Point(currentTile.X + 1, currentTile.Y - 2),
-                new Point(currentTile.X - 1, currentTile.Y - 2),
-
-                new Point(currentTile.X + 1, currentTile.Y + 2),
-                new Point(currentTile.X - 1, currentTile.Y + 2),
-            };
-
-            foreach(var point in pointsToCheck)
-            {
-                if (!(destinationTile.Y == point.Y && destinationTile.X == point.X)) continue;
-
-                var enemy = board.PieceAt(point.X, point.Y);
-                if (enemy == null) return true;
-                if (enemy != null && enemy.IsWhite != this.IsWhite) return true;
-                if (enemy != null && enemy != this) continue;
-            }
-
-            return false;
-        }
-    }
-}
+using System;

+using System.Collections.Generic;

+using System.Drawing;

+using System.Linq;

+using System.Text;

+using System.Threading.Tasks;

+

+namespace Chess.Pieces

+{

+    class Knight : ChessPiece

+    {

+        public Knight(bool isWhite) : base(isWhite)

+        {

+            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_knight_png_shadow_256px : Chess.Properties.Resources.w_knight_png_shadow_256px);

+        }

+

+        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)

+        {

+            Point[] pointsToCheck = {

+                new Point(currentTile.X - 2, currentTile.Y - 1),

+                new Point(currentTile.X - 2, currentTile.Y + 1),

+

+                new Point(currentTile.X + 2, currentTile.Y - 1),

+                new Point(currentTile.X + 2, currentTile.Y + 1),

+

+                new Point(currentTile.X + 1, currentTile.Y - 2),

+                new Point(currentTile.X - 1, currentTile.Y - 2),

+

+                new Point(currentTile.X + 1, currentTile.Y + 2),

+                new Point(currentTile.X - 1, currentTile.Y + 2),

+            };

+

+            foreach(var point in pointsToCheck)

+            {

+                if (!(destinationTile.Y == point.Y && destinationTile.X == point.X)) continue;

+

+                var enemy = board.PieceAt(point.X, point.Y);

+                if (enemy == null) return true;

+                if (enemy != null && enemy.IsWhite != this.IsWhite) return true;

+                if (enemy != null && enemy != this) continue;

+            }

+

+            return false;

+        }

+    }

+}

diff --git a/Pieces/Pawn.cs b/Pieces/Pawn.cs
index 93be545..60ce309 100644
--- a/Pieces/Pawn.cs
+++ b/Pieces/Pawn.cs
@@ -1,42 +1,102 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Chess.Pieces
-{
-    class Pawn : ChessPiece
-    {
-        private bool firstMove = true;
-
-        public Pawn(bool isWhite) : base(isWhite)
-        {
-            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_pawn_png_shadow_256px : Chess.Properties.Resources.w_pawn_png_shadow_256px);
-        }
-
-        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)
-        {
-            MoveCheckResult result;
-
-            int space = 2;
-            if (!firstMove) space = 1;
-
-            if (!IsWhite)
-            {
-                result = CanMoveDown(board, currentTile, destinationTile, space);
-                if (result == MoveCheckResult.CanMove) return true;
-                if (result == MoveCheckResult.CantMove) return false;
-            }
-            else
-            {
-                result = CanMoveUp(board, currentTile, destinationTile, space);
-                if (result == MoveCheckResult.CanMove) return true;
-                if (result == MoveCheckResult.CantMove) return false;
-            }
-
-            return false;
-        }  
-    }
-}
+using System;

+using System.Collections.Generic;

+using System.Drawing;

+using System.Linq;

+using System.Text;

+using System.Threading.Tasks;

+

+namespace Chess.Pieces

+{

+    class Pawn : ChessPiece

+    {

+        private bool firstMove = true;

+

+        public Pawn(bool isWhite) : base(isWhite)

+        {

+            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_pawn_png_shadow_256px : Chess.Properties.Resources.w_pawn_png_shadow_256px);

+        }

+

+        public override void PostMovementEvent(BoardTile tile)

+        {

+            firstMove = false;

+

+            // Pawn upgrade to queen

+            if (tile.OccupyingPiece == this)

+            {

+                if ((this.IsWhite && tile.Y == 0) || (!this.IsWhite && tile.Y == 7))

+                {

+                    tile.OccupyingPiece = new Queen(this.IsWhite);

+                }

+            }

+

+            base.PostMovementEvent(tile);

+        }

+

+        internal override MoveCheckResult CanMoveDown(ChessBoard board, BoardTile currentTile, BoardTile destinationTile, int count = ChessBoard.BoardSize)

+        {

+            var result = base.CanMoveDown(board, currentTile, destinationTile, count);

+

+            if (result == MoveCheckResult.CanMove)

+            {

+                if (destinationTile.OccupyingPiece != null) result = MoveCheckResult.CantMove;

+            }

+

+            return result;

+        }

+

+        internal override MoveCheckResult CanMoveUp(ChessBoard board, BoardTile currentTile, BoardTile destinationTile, int count = ChessBoard.BoardSize)

+        {

+            var result = base.CanMoveUp(board, currentTile, destinationTile, count);

+

+            if (result == MoveCheckResult.CanMove)

+            {

+                if (destinationTile.OccupyingPiece != null) result = MoveCheckResult.CantMove;

+            }

+

+            return result;

+        }

+

+        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)

+        {

+            MoveCheckResult result;

+

+            int space = 2;

+            if (!firstMove) space = 1;

+

+            if (!IsWhite)

+            {

+                result = CanMoveDown(board, currentTile, destinationTile, space);

+                if (result == MoveCheckResult.CanMove) return true;

+                if (result == MoveCheckResult.CantMove) return false;

+

+                // take left

+                result = CanMoveDownLeft(board, currentTile, destinationTile, 1);

+                if (result == MoveCheckResult.CanMove && destinationTile.OccupyingPiece != null && destinationTile.OccupyingPiece.IsWhite != IsWhite) return true;

+                if (result == MoveCheckResult.CantMove) return false;

+

+                // take right

+                result = CanMoveDownRight(board, currentTile, destinationTile, 1);

+                if (result == MoveCheckResult.CanMove && destinationTile.OccupyingPiece != null && destinationTile.OccupyingPiece.IsWhite != IsWhite) return true;

+                if (result == MoveCheckResult.CantMove) return false;

+            }

+            else

+            {

+                result = CanMoveUp(board, currentTile, destinationTile, space);

+                if (result == MoveCheckResult.CanMove) return true;

+                if (result == MoveCheckResult.CantMove) return false;

+

+                // take left

+                result = CanMoveUpLeft(board, currentTile, destinationTile, 1);

+                if (result == MoveCheckResult.CanMove && destinationTile.OccupyingPiece != null && destinationTile.OccupyingPiece.IsWhite != IsWhite) return true;

+                if (result == MoveCheckResult.CantMove) return false;

+

+                // take right

+                result = CanMoveUpRight(board, currentTile, destinationTile, 1);

+                if (result == MoveCheckResult.CanMove && destinationTile.OccupyingPiece != null && destinationTile.OccupyingPiece.IsWhite != IsWhite) return true;

+                if (result == MoveCheckResult.CantMove) return false;

+            }

+

+            return false;

+        }  

+    }

+}

diff --git a/Pieces/Queen.cs b/Pieces/Queen.cs
index 42998c4..6b1fb0b 100644
--- a/Pieces/Queen.cs
+++ b/Pieces/Queen.cs
@@ -1,59 +1,59 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Linq;
-using System.Runtime.InteropServices.WindowsRuntime;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Chess.Pieces
-{
-    class Queen : ChessPiece
-    {
-        public Queen(bool isWhite) : base(isWhite)
-        {
-            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_queen_png_shadow_256px : Chess.Properties.Resources.w_queen_png_shadow_256px);
-        }
-
-        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)
-        {
-            MoveCheckResult result;
-
-            result = CanMoveDown(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveUp(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveLeft(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveRight(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            // diagonal 
-
-            result = CanMoveDownLeft(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveDownRight(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveUpLeft(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveUpRight(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            return false;
-        }
-    }
-}
+using System;

+using System.Collections.Generic;

+using System.Drawing;

+using System.Linq;

+using System.Runtime.InteropServices.WindowsRuntime;

+using System.Text;

+using System.Threading.Tasks;

+

+namespace Chess.Pieces

+{

+    class Queen : ChessPiece

+    {

+        public Queen(bool isWhite) : base(isWhite)

+        {

+            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_queen_png_shadow_256px : Chess.Properties.Resources.w_queen_png_shadow_256px);

+        }

+

+        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)

+        {

+            MoveCheckResult result;

+

+            result = CanMoveDown(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveUp(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveLeft(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveRight(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            // diagonal 

+

+            result = CanMoveDownLeft(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveDownRight(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveUpLeft(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveUpRight(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            return false;

+        }

+    }

+}

diff --git a/Pieces/Rook.cs b/Pieces/Rook.cs
index 29c17c0..b6a0422 100644
--- a/Pieces/Rook.cs
+++ b/Pieces/Rook.cs
@@ -1,40 +1,64 @@
-using System;
-using System.Collections.Generic;
-using System.Drawing;
-using System.Linq;
-using System.Text;
-using System.Threading.Tasks;
-
-namespace Chess.Pieces
-{
-    class Rook : ChessPiece
-    {
-        public Rook(bool isWhite) : base(isWhite)
-        {
-            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_rook_png_shadow_256px : Chess.Properties.Resources.w_rook_png_shadow_256px);
-        }
-
-        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)
-        {
-            MoveCheckResult result;
-
-            result = CanMoveDown(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveUp(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveLeft(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            result = CanMoveRight(board, currentTile, destinationTile);
-            if (result == MoveCheckResult.CanMove) return true;
-            if (result == MoveCheckResult.CantMove) return false;
-
-            return false;
-        }
-    }
-}
+using System;

+using System.Collections.Generic;

+using System.Drawing;

+using System.Linq;

+using System.Text;

+using System.Threading.Tasks;

+

+namespace Chess.Pieces

+{

+    class Rook : ChessPiece

+    {

+        public bool IsInInitialPosition { get; private set; }

+

+        public Rook(bool isWhite) : base(isWhite)

+        {

+            PieceImage = new Bitmap(!isWhite ? Chess.Properties.Resources.b_rook_png_shadow_256px : Chess.Properties.Resources.w_rook_png_shadow_256px);

+            IsInInitialPosition = true;

+        }

+

+        public override void PostMovementEvent(BoardTile tile)

+        {

+            this.IsInInitialPosition = false;

+

+            base.PostMovementEvent(tile);

+        }

+

+        public override bool CanMoveTo(ChessBoard board, BoardTile currentTile, BoardTile destinationTile)

+        {

+            MoveCheckResult result;

+

+            result = CanMoveDown(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveUp(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveLeft(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            result = CanMoveRight(board, currentTile, destinationTile);

+            if (result == MoveCheckResult.CanMove) return true;

+            if (result == MoveCheckResult.CantMove) return false;

+

+            return false;

+        }

+

+        internal BoardTile GetCastleLocation(ChessBoard board, BoardTile tile)

+        {

+            if (tile.X == 0)

+            {

+                return board.Tiles[tile.Y, tile.X + 3];

+            }

+            else if (tile.X == 7)

+            {

+                return board.Tiles[tile.Y, tile.X - 2];

+            }

+

+            return tile;

+        }

+    }

+}