🎮 Board Game Center

A comprehensive C++ board game collection featuring 13 unique game variants, built with object-oriented programming principles. This project demonstrates advanced OOP concepts including inheritance, polymorphism, templates, and design patterns.

📋 Table of Contents

• Overview
• Features
• Game Variants
• Architecture
• Technologies Used
• Getting Started
• Project Structure
• Documentation
• Contributing

🎯 Overview

The Board Game Center is an interactive console application that brings together multiple board game variants in a single, unified platform. Built entirely in C++, it showcases professional software engineering practices with a clean, extensible architecture that makes adding new games straightforward.

The project features:

• 13 different game variants ranging from classic Tic-Tac-Toe to unique variations
• Object-oriented design with templated base classes for maximum code reuse
• Interactive menu system with colorized console output
• Multiple player modes including Human vs Human, Human vs AI, and AI vs AI
• Professional documentation using Doxygen
• Modular architecture that separates game logic, UI, and player management

✨ Features

Core Features

• 🎨 Colorized Console Interface - Enhanced user experience with ANSI color codes
• 🤖 AI Players - Multiple AI difficulty levels for single-player experience
• 🎲 Random Player Mode - Computer players that make random valid moves
• ⌨️ Keyboard Navigation - Arrow key support for menu navigation
• 🔄 Game Selection Menu - Easy switching between different game variants
• 📊 Win/Loss/Draw Detection - Automatic game state tracking
• 🎯 Move Validation - Intelligent validation for all game types

Technical Features

• Generic templated base classes (Board<T>, Player<T>, UI<T>)
• Factory pattern for dynamic game instantiation
• Separation of concerns (Game logic, UI, Player management)
• Extensive inline documentation
• Clean code principles and consistent naming conventions

🎲 Game Variants

The Board Game Center includes 13 unique game variants:

1. Numerical Tic-Tac-Toe

Players use numbers instead of X's and O's. Player 1 uses odd numbers (1, 3, 5, 7, 9) and Player 2 uses even numbers (2, 4, 6, 8). The goal is to create a line that sums to 15.

2. 4×4 Tic-Tac-Toe

A larger 4×4 grid where players need to align 4 symbols in a row, column, or diagonal to win. More strategic depth than traditional 3×3.

3. Misère Tic-Tac-Toe

A reverse variant where the objective is to avoid getting three in a row. The first player to create three in a row loses!

4. Infinity Tic-Tac-Toe

Players can move their existing pieces after all pieces are placed, creating an endless strategic game where positions constantly shift.

5. 5×5 Tic-Tac-Toe

An expanded 5×5 board where players compete to create sequences of their symbol, adding complexity and strategic options.

6. S-U-S Sequence Game

Players place S's and U's attempting to create the sequence "SUS" in any direction. A unique word-based twist on traditional gameplay.

7. Diamond Tic-Tac-Toe

Features a diamond-shaped board layout, requiring players to adapt their strategies to the unique geometry.

8. Pyramid Tic-Tac-Toe

A triangular/pyramid-shaped board where the playing area is arranged in pyramid layers, offering a fresh spatial challenge.

9. Dynamic Obstacle Tic-Tac-Toe

The board contains randomly placed obstacles that block certain positions, forcing players to adapt their strategies dynamically.

10. Ultimate Tic-Tac-Toe

A meta-game consisting of 9 small Tic-Tac-Toe boards arranged in a 3×3 grid. Your move determines which board your opponent must play on next.

11. Connect Four

The classic gravity-based game where players drop tokens into columns, trying to align 4 tokens horizontally, vertically, or diagonally.

12. Word Tic-Tac-Toe

Players form words on the board, combining wordplay with strategic positioning for a unique challenge.

13. Memory Tic-Tac-Toe

A memory-based variant where players must remember positions and make strategic decisions based on hidden information.

🏗️ Architecture

The project follows a clean, object-oriented architecture with three main layers:

Base Classes (Templates)

template <typename T> class Board

• Manages game board state
• Provides virtual methods for game logic
• Handles move validation and game state checks

template <typename T> class Player

• Represents a player (Human, AI, Random, Computer)
• Manages player symbols and turn logic
• Handles move input based on player type

template <typename T> class UI

• Manages user interaction and display
• Handles player setup and game flow
• Provides game-specific input/output

Game-Specific Implementations

Each game variant provides:

• [Game]_Board - Inherits from Board<char> with specific game rules
• [Game]_UI - Inherits from UI<char> for game-specific interactions
• Custom win/draw/lose conditions
• Specialized display and validation logic

Game Manager

The GameManager class orchestrates:

• Player turns and move processing
• Win/draw/lose detection
• Game loop control
• State management

Design Patterns

• Factory Pattern - Dynamic game instantiation using lambda factories
• Template Method Pattern - Base game flow with customizable steps
• Strategy Pattern - Different player types (Human, AI, Random)
• Polymorphism - Virtual methods for game-specific behavior

💻 Technologies Used

• Language: C++ (C++11 and later)
• Platform: Cross-platform console application (Windows/Linux)
• Libraries:
  • Standard Template Library (STL)
  • <conio.h> for keyboard input (Windows)
  • ANSI escape codes for terminal styling
• Documentation: Doxygen
• Build Tools: C++ compiler (g++, MSVC, or Clang)

🚀 Getting Started

Prerequisites

• C++ compiler supporting C++11 or later (g++, MSVC, Clang)
• Terminal/Console with ANSI color support (recommended)
• Windows environment for <conio.h> features (or alternative for Linux)

Compilation

Using CMake (Recommended)

# Create a build directory
mkdir build
cd build

# Generate build files
cmake ..

# Build the project
cmake --build .

This will compile all source files and create the GameCenter executable in the build directory.

Using Make (Alternative)

make

This will compile all source files and create the GameCenter executable.

Manual Compilation - Using g++ (Linux/MinGW)

g++ -std=c++11 -Iinclude src/*.cpp -o GameCenter

Manual Compilation - Using MSVC (Windows)

cl /EHsc /std:c++11 /Iinclude src\*.cpp /Fe:GameCenter.exe

Running the Application

# If built with CMake
./build/GameCenter        # Linux/Mac
build\GameCenter.exe      # Windows

# If built with Make or manual compilation
./GameCenter        # Linux/Mac
GameCenter.exe      # Windows

Usage

1. Launch the application - You'll see a colorized welcome menu
2. Navigate - Use arrow keys (↑/↓) to select a game
3. Select a game - Press Enter to start your chosen game
4. Setup players - Choose player types (Human, AI, Random, Computer)
5. Play - Follow on-screen prompts to make moves
6. Repeat - Return to the menu to try different games

Player Types

• Human: Manual input for each move
• Computer: Basic AI that makes strategic moves
• Random: Makes random valid moves
• AI: Advanced AI with improved decision-making

📁 Project Structure

GameBoards/
├── include/                   # Header files
│   ├── BoardGame_Classes.h   # Base template classes
│   ├── Menu.h                # Menu system header
│   ├── console_style.hpp     # Terminal styling utilities
│   ├── XO_Classes.h         # Standard Tic-Tac-Toe
│   ├── Numerical_Classes.h  # Numerical variant
│   ├── 4X4_Classes.h        # 4×4 grid variant
│   ├── 5X5_Classes.h        # 5×5 grid variant
│   ├── Misere_XO_Classes.h  # Reverse rules variant
│   ├── Infinity_Classes.h   # Movable pieces variant
│   ├── SUS_Classes.h        # Sequence game variant
│   ├── Diamond_Classes.h    # Diamond board variant
│   ├── Pyramid_Classes.h    # Pyramid board variant
│   ├── Dynamic_Obstacle_Classes.h  # Obstacle variant
│   ├── Ultimate_Classes.h   # Meta-game variant
│   ├── ConnectFour_Classes.h # Connect Four game
│   ├── Word_Classes.h       # Word formation variant
│   └── Memory_Classes.h     # Memory-based variant
│
├── src/                      # Source files
│   ├── main.cpp             # Main entry point and game registry
│   ├── Menu.cpp             # Menu system implementation
│   ├── XO_Classes.cpp       # Standard Tic-Tac-Toe
│   ├── Numerical_Classes.cpp # Numerical variant
│   ├── 4X4_Classes.cpp      # 4×4 grid variant
│   ├── 5X5_Classes.cpp      # 5×5 grid variant
│   ├── Misere_XO_Classes.cpp # Reverse rules variant
│   ├── Infinity_Classes.cpp # Movable pieces variant
│   ├── SUS_Classes.cpp      # Sequence game variant
│   ├── Diamond_Classes.cpp  # Diamond board variant
│   ├── Pyramid_Classes.cpp  # Pyramid board variant
│   ├── Dynamic_Obstacle_Classes.cpp # Obstacle variant
│   ├── Ultimate_Classes.cpp # Meta-game variant
│   ├── ConnectFour_Classes.cpp # Connect Four game
│   ├── Word_Classes.cpp     # Word formation variant
│   └── Memory_Classes.cpp   # Memory-based variant
│
├── docs/                     # Documentation
│   ├── Doxyfile             # Doxygen configuration
│   └── html/                # Generated API documentation
│
├── CMakeLists.txt            # CMake build configuration
├── Makefile                  # Make build configuration (alternative)
└── README.md                 # Project documentation

Key Files

• include/BoardGame_Classes.h: Contains the generic base classes (Board<T>, Player<T>, UI<T>, GameManager<T>)
• src/main.cpp: Main application logic with game factory registry
• include/Menu.h / src/Menu.cpp: Interactive menu system with keyboard navigation
• include/console_style.hpp: ANSI color codes and terminal formatting
• include/[Game]_Classes.h / src/[Game]_Classes.cpp: Each game variant's implementation
• CMakeLists.txt: CMake build configuration for cross-platform compilation
• Makefile: Make build automation (alternative build method)

📚 Documentation

Generating Documentation

The project uses Doxygen for comprehensive API documentation. To generate:

cd docs
doxygen Doxyfile

Documentation will be generated in the docs/html/ directory. Open docs/html/index.html in a browser to view.

Code Documentation

All classes and functions are extensively documented with:

• Detailed descriptions
• Parameter explanations
• Return value documentation
• Usage examples where applicable
• Implementation notes

Documentation Highlights

• Class hierarchies - Visual inheritance diagrams
• Call graphs - Function relationship visualization
• File dependencies - Include file relationships
• Detailed method documentation - Every public and protected method

🤝 Contributing

This project was developed as part of an OOP assignment. Contributions, suggestions, and feedback are welcome!

Development Guidelines

1. Follow the existing code style and naming conventions
2. Document all new classes and methods using Doxygen format
3. Ensure new games implement all required virtual methods
4. Test thoroughly before submitting changes
5. Update this README if adding new features or games

Adding a New Game

To add a new game variant:

1. Create include/[YourGame]_Classes.h and src/[YourGame]_Classes.cpp
2. Implement [YourGame]_Board : public Board<char>
3. Implement [YourGame]_UI : public UI<char>
4. Add factory functions to the games vector in src/main.cpp
5. Add game name to the options vector
6. Add the new source file to CMakeLists.txt in the SOURCES list
7. Compile using cmake or make and test

📊 Project Statistics

• Total Lines of Code: 6,000+ lines
• Number of Classes: 39+ classes
• Game Variants: 13 unique games
• Languages: C++ with extensive STL usage
• Documentation: Comprehensive Doxygen comments

🎓 Educational Value

This project demonstrates:

• Object-Oriented Programming - Inheritance, polymorphism, encapsulation
• Generic Programming - Template classes and functions
• Design Patterns - Factory, Strategy, Template Method
• Code Organization - Separation of concerns, modular design
• Software Documentation - Professional documentation practices
• User Interface Design - Console-based interactive applications

📝 License

This project is part of an academic assignment. Please check with the repository owner regarding usage and licensing.

👥 Contributors

• Mohammad Abdulhakim - @MohammadAbdulhakim
• Amr Tamer - @AmrTamer117
• Shaza Mosad
• Ali Mohamed

Acknowledgments

• Developed as part of an Object-Oriented Programming course assignment
• Inspired by classic board games and their variants
• Built with modern C++ best practices

---

Enjoy playing! 🎮