Chess

October, 2023

A Unity-based chess game with full rule implementation, move validation, and interactive highlights. Supports standard moves like castling, en passant, and pawn promotion for accurate chess gameplay.

Introduction

Overview: This Unity-based chess game is a turn-based local multiplayer experience that brings the classic game of chess to life with interactive highlighting of legal moves and full rule adherence.
Motivation: I developed this project as an opportunity to challenge my coding skills and tackle the logic complexities of chess gameplay.

Key Features

Move Validation and Highlighting: The game visually displays each piece’s legal moves, allowing players to easily navigate their options while respecting chess rules.
Special Moves and Rule Compliance: The game supports pawn promotion, castling, and en passant, making gameplay accurate to chess’s full ruleset.
Game State Detection: Detects and handles check, checkmate, and stalemate, automatically ending the game or updating the interface to reflect the game state.
User Interface and Control: The interface includes a game-over panel, a pawn promotion selector, a timer, and a pause menu that allows players to resume, restart, or quit.
Interactive Camera Rotation: The camera auto-rotates to match the perspective of the active team, keeping players oriented to their turn.
Basic Session Timer: Tracks and displays the duration of each game.

Key Challenges & Solutions

1. Move Validation Across Different Pieces

Challenge: Each chess piece has unique movement rules that must be validated, including blocking pieces, and special moves like castling and en passant. Ensuring this was accomplished without relying on Unity’s physics system (e.g., raycasts or colliders) added complexity.
Solution: Movement is defined programmatically using arrays of vector directions combined with distance constraints. Each piece uses a dedicated MoveValidator class to interpret these vectors and validate potential moves algorithmically, checking against the board state. This purely mathematical approach ensures precision, efficiency, and independence from Unity’s physics system.

2. King Safety through Move Simulation

Challenge: Preventing any move from leaving the king in check required simulating potential outcomes before allowing moves.
Solution: Moves are validated with a temporary state simulation, testing each potential move by applying it to a copy of the board and checking for king safety. If a move results in the king being in check, it is excluded from valid options.

3. Handling Special Moves like Castling and En Passant

Challenge: Special moves require additional conditions, such as verifying king and rook inactivity for castling or tracking a pawn’s movement for en passant.
Solution: Created custom data classes (KingCastleMoveData, PawnEnPassantMoveData, etc.) to store conditions and dependencies for special moves. This structure isolates special move logic from general movement code, keeping the system organized and modular.

4. Board Management and Piece Tracking

Challenge: Efficiently tracking piece positions, managing captures, and updating board state dynamically was critical for gameplay consistency.
Solution: Implemented a BoardManager class with a dictionary of piece positions for fast lookups and updates. It handles piece additions, removals, and positional changes, ensuring consistent board state representation.

5. Visual Feedback for Moves

Challenge: Players needed clear visual indicators for move options and selected pieces to make gameplay more intuitive.
Solution: A MoveHighlighter component overlays the board with instantiated visual markers showing selected pieces and their valid move positions. These markers dynamically update and clear after each piece selection or move.

6. Capture Handling and Display

Challenge: Captured pieces needed to be removed from active play while remaining visible for player reference.
Solution: Created a CaptureZone class to manage captured pieces, moving them to a designated display area with rows of predefined available positions. Pieces are animated to this zone and organized by team, keeping the main board clear while maintaining visibility.

7. Interactive Board Management

Challenge: The interplay between move validation, king safety, special moves, and captures required seamless coordination.
Solution: The board system ties together validators, the king safety check, and piece tracking, ensuring all systems interact dynamically. For example, a validated move from a MoveValidator triggers state updates in the BoardManager, which in turn updates the visual feedback and capture zones.

Future Development

AI Opponent: Adding a single-player mode with an AI opponent for users who prefer playing solo.
Move History & Undo Feature: Implementing a feature to review and potentially undo moves, adding flexibility for players.
Enhanced Visuals & UI: Integrating move and capture animations, sound effects, and UI refinements for a more polished experience.
Additional Game Modes: Exploring timed modes like speed chess to provide varied gameplay options.

Key Takeaways

Building this chess game was a valuable experience that pushed my problem-solving skills, particularly in handling rule-based logic, managing dynamic board states, and translating chess rules into algorithms. The process was both challenging and enjoyable.