Project Overview

A fully playable Blackjack game implemented in C++ using console input and object-oriented design.

This project focuses on implementing the complete gameplay loop of Blackjack using structured C++ systems including deck management, card shuffling, betting logic, player decision handling, and dealer AI behavior.

The goal of the project was to explore procedural game logic, input validation, state management, and object-oriented design patterns while implementing a classic casino card game entirely in code without external libraries or graphical frameworks.

The game supports advanced Blackjack mechanics such as card splitting, double-down betting, dealer draw rules, dynamic credit tracking, and full round resolution with win/loss evaluation.

My Role

I developed the entire game system including the card logic, game loop, betting mechanics, and player input handling using C++.

• Designed object-oriented game architecture using classes and structs
• Implemented Fisher–Yates shuffle algorithm for random deck generation
• Built full Blackjack rule logic including splitting and doubling down
• Created dynamic credit and betting system
• Implemented dealer AI following standard Blackjack rules
• Developed robust console input validation and game state flow

This project served as an exercise in structuring complex gameplay systems and managing multiple interacting rulesets within a clean and maintainable code architecture.

Key Technical Highlights

• Fisher–Yates Shuffle Algorithm: The deck is randomized using the Fisher–Yates shuffle, ensuring unbiased card distribution and realistic gameplay randomness.
• Object-Oriented Game Structure: The project uses a central Game class alongside Card and Hand structures to encapsulate deck data, player state, and round management.
• Dynamic Hand Evaluation System: Hand totals are calculated dynamically with special handling for Aces, allowing them to count as either 1 or 11 depending on the hand value.
• Advanced Blackjack Mechanics: The game supports double-down betting, hand splitting, dealer draw rules, and multiple hand resolution within a single round.
• Robust Input Validation: Console input is sanitized to prevent invalid bets or incorrect player commands from breaking the game loop.
• State-Based Round Flow: Each round transitions through clear gameplay phases: deal → player turn → dealer turn → result evaluation.

Gameplay Highlights

Deck Generation & Shuffle

The game dynamically generates a full 52-card deck and randomizes its order using the Fisher–Yates shuffle algorithm to ensure fair and unpredictable gameplay.

How it works

• A 52-card array is generated using nested loops.
• Each card contains suit, rank, and numeric value.
• The Fisher–Yates algorithm swaps card positions randomly.
• The shuffled deck is then used sequentially for dealing.

Key Code Systems

• initializeDeck() – Creates the card deck.
• shuffleDeck() – Randomizes card order.
• dealCard() – Returns the next card in the deck.

Player Decision System

Players can interact with the game using console commands to hit, stand, double down, split hands, or pass a round. The system dynamically checks rules and available credits before allowing each action.

Why it’s done this way

• Ensures Blackjack rules are followed correctly.
• Prevents invalid actions such as splitting with mismatched cards.
• Allows dynamic gameplay based on the player's credits and hand state.

Key Systems

• playerTurn() – Handles all player input decisions.
• calculateHandValue() – Evaluates current hand total.
• displayHand() – Prints cards and hand values.

Dealer AI & Round Resolution

The dealer follows standard Blackjack rules, drawing cards until reaching a minimum hand value of 17. After the dealer turn, the game compares results and adjusts player credits based on win/loss outcomes.

How it works

• The dealer automatically draws cards until reaching 17.
• Both hands are evaluated for busts or higher totals.
• The player’s credits are updated based on the result.

Key Systems

• dealerTurn() – Handles dealer card drawing.
• finishRound() – Evaluates winners and payouts.
• resetGame() – Resets credits and hands for a new session.

Robust Input Validation System

The blackjack game uses a dedicated input validation function to ensure that player bets are always valid numeric values. Since console programs rely heavily on user input, invalid values such as characters or malformed numbers could otherwise break the game logic.

Why it’s done this way

• Prevents crashes caused by invalid console input.
• Ensures only valid numeric bets are processed.
• Keeps the game loop stable without restarting the program.
• Improves user experience by prompting for corrected input.

How it works

• Checks if the input stream entered a failure state using std::cin.fail().
• Uses std::cin.peek() to detect leftover invalid characters in the input buffer.
• If invalid input is detected, the error state is cleared.
• The input buffer is flushed using std::cin.ignore().
• The player is prompted again until valid input is entered.

Code Snippet

• inputValidation(int &bet) – Ensures the player's bet input is a valid number.

Contact