Twenty-one Game using MEAN Stack

//index.js

const express = require('express');
const cors = require('cors');
const bodyParser = require('body-parser');
const path = require('path');
const { setupGameRoutes } = require('./game');
const { connectToDatabase } = require('./db');

const app = express();
const PORT = process.env.PORT || 5000;

app.use(cors());
app.use(bodyParser.json());

// Connect to the database
connectToDatabase();

// Setup game routes
setupGameRoutes(app);

// Serve static files from the Angular app
app.use(express.static(path
    .join(__dirname, '..', 'client', 'dist')));
app.get('*', (req, res) => {
    res.sendFile(path
        .join(__dirname, '..', 'client', 'dist', 'index.html'));
});

// Start the server
app.listen(PORT, () => {
    console.log(`Server is running on port ${PORT}`);
});

//game.js
const { Card, Player, Game } = require('./db');

// Helper function to create a new deck
function createDeck() {
    const suits = ['Hearts', 'Diamonds', 'Clubs', 'Spades'];
    const ranks = ['2', '3', '4', '5', '6', '7',
                     '8', '9', '10', 'J', 'Q', 'K', 'A'];

    const deck = [];
    for (const suit of suits) {
        for (const rank of ranks) {
            const card = new Card({
                suit: suit,
                rank: rank,
                value: rank === 'A' ? 11 :
                     isNaN(rank) ? 10 : parseInt(rank),
            });
            deck.push(card);
        }
    }

    return deck;
}

// Helper function to calculate the score of a hand
function calculateScore(hand) {
    let score = hand.reduce((total, card) =>
         total + card.value, 0);

    // Handle Aces (reduce value from 11 to 1 if necessary)
    hand.filter(card => card.rank === 'A')
    .forEach(_ => {
        if (score > 21) {
            score -= 10;
        }
    });

    return score;
}

// Helper function to determine the winner
function determineWinner(playerScore, dealerScore) {
    if (playerScore > 21) {
        return 'Dealer'; // Player busts, dealer wins
    }

    if (dealerScore > 21) {
        return 'Player'; // Dealer busts, player wins
    }

    if (playerScore > dealerScore) {
        return 'Player'; // Player has a higher score
    } else if (playerScore < dealerScore) {
        return 'Dealer'; // Dealer has a higher score
    } else {
        return 'Draw'; // Scores are equal, it's a draw
    }
}

// Setup game routes
function setupGameRoutes(app) {
    // Endpoint to start a new game
    app.post('/game/start', async (req, res) => {
        try {
            const newDeck = createDeck();

            // Shuffle the deck (Fisher-Yates algorithm)
            for (let i = newDeck.length - 1; i > 0; i--) {
                const j = Math.floor(Math.random() * (i + 1));
                [newDeck[i], newDeck[j]] = [newDeck[j], newDeck[i]];
            }

            const newGame = new Game({
                deck: newDeck,
                player: { name: 'Player', hand: [], score: 0 },
                dealer: { name: 'Dealer', hand: [], score: 0 },
            });

            // Deal the initial two cards to the player and the dealer
            newGame.player.hand.push(newGame.deck.pop());
            newGame.dealer.hand.push(newGame.deck.pop());
            newGame.player.hand.push(newGame.deck.pop());
            newGame.dealer.hand.push(newGame.deck.pop());

            // Update scores
            newGame.player.score = calculateScore(newGame.player.hand);
            newGame.dealer.score = calculateScore(newGame.dealer.hand);

            // Save the new game to the database
            await newGame.save();

            res.status(201).json(newGame);
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    });

    // Endpoint to handle player hits
    app.post('/game/hit', async (req, res) => {
        try {
            const gameId = req.body.gameId;

            // Fetch the game from the database
            const game = await Game.findById(gameId);

            // Draw a card from the deck and add it to the player's hand
            const drawnCard = game.deck.pop();
            game.player.hand.push(drawnCard);

            // Update the player's score
            game.player.score = calculateScore(game.player.hand);

            // Set the winner field
            game.winner = determineWinner(game.player.score, game.dealer.score);

            // Save the updated game to the database
            await game.save();

            res.json({ ...game.toObject(), winner: game.winner });
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    });

    // Endpoint to handle player standing
    app.post('/game/stand', async (req, res) => {
        try {
            const gameId = req.body.gameId;

            // Fetch the game from the database
            const game = await Game.findById(gameId);

            // Dealer draws cards until their score is 17 or higher
            while (game.dealer.score < 17) {
                const drawnCard = game.deck.pop();
                game.dealer.hand.push(drawnCard);
                game.dealer.score = calculateScore(game.dealer.hand);
            }

            // Set the winner field
            game.winner = determineWinner(game.player.score, game.dealer.score);

            // Save the updated game to the database
            await game.save();

            res.json({ ...game.toObject(), winner: game.winner });
        } catch (error) {
            console.error(error);
            res.status(500).send('Internal Server Error');
        }
    });
}

module.exports = { createDeck, calculateScore, determineWinner, setupGameRoutes };

//db.js

const mongoose = require('mongoose');

// Database connection configuration
function connectToDatabase() {
    mongoose.connect('mongodb://localhost:27017/blackjack', {
        useNewUrlParser: true,
        useUnifiedTopology: true,
    });
}

const cardSchema = new mongoose.Schema({
    suit: String,
    rank: String,
    value: Number,
});

const playerSchema = new mongoose.Schema({
    name: String,
    hand: [cardSchema],
    score: Number,
});

const gameSchema = new mongoose.Schema({
    deck: [cardSchema],
    player: playerSchema,
    dealer: playerSchema,
    winner: String,
});

const Card = mongoose.model('Card', cardSchema);
const Player = mongoose.model('Player', playerSchema);
const Game = mongoose.model('Game', gameSchema);

module.exports = { connectToDatabase, Card, Player, Game };

//src/app/game/game.component.ts

import { Component, OnInit } from '@angular/core';
import { HttpClient } from '@angular/common/http';

@Component({
    selector: 'app-game',
    templateUrl: './game.component.html',
    styleUrls: ['./game.component.css']
})
export class GameComponent implements OnInit {
    gameState: any;
    winnerMessage: string = '';

    constructor(private http: HttpClient) { }

    ngOnInit(): void {
        this.startNewGame();
    }

    startNewGame(): void {
        this.http.post<any>('http://localhost:5000/game/start', {})
            .subscribe(response => {
                this.gameState = response;
                this.winnerMessage = '';
            }, error => console
                .error('Error starting a new game:', error));
    }

    handleHit(): void {
        this.http.post<any>('http://localhost:5000/game/hit', 
        { gameId: this.gameState._id })
            .subscribe(response => {
                this.gameState = response;
                this.checkWinner(response.winner);
            }, error => console
                .error('Error hitting:', error));
    }

    handleStand(): void {
        this.http.post<any>('http://localhost:5000/game/stand',
         { gameId: this.gameState._id })
            .subscribe(response => {
                this.gameState = response;
                this.checkWinner(response.winner);
            }, error => console.error('Error standing:', error));
    }

    checkWinner(winner: string): void {
        this.winnerMessage = `Winner: ${winner}`;
        setTimeout(() => {
            this.startNewGame();
        }, 3000);
    }
}

//app.component.ts

import { Component } from '@angular/core';

@Component({
    selector: 'app-root',
    templateUrl: './app.component.html',
    styleUrls: ['./app.component.css']
})
export class AppComponent {
}

//app.module.ts

import { BrowserModule } from '@angular/platform-browser';
import { NgModule } from '@angular/core';
import { HttpClientModule } from '@angular/common/http';
import { AppComponent } from './app.component';
import { GameComponent } from './game/game.component';

@NgModule({
    declarations: [
        AppComponent,
        GameComponent
    ],
    imports: [
        BrowserModule,
        HttpClientModule
    ],
    providers: [],
    bootstrap: [AppComponent]
})
export class AppModule { }

//app.routes.ts

import { Routes } from '@angular/router';

export const routes: Routes = [];

//main.ts

import { platformBrowserDynamic } from '@angular/platform-browser-dynamic';
import { AppModule } from './app/app.module';

platformBrowserDynamic().bootstrapModule(AppModule)
  .catch(err => console.error(err));