【C言語】ブラックジャックをするプログラムの作成方法

2023-09-072024-07-26

この記事では、C言語を使ってブラックジャックというカードゲームをプログラムする方法を紹介します。

ゲームの基本ルールやプレイヤーとディーラーの役割を理解し、実際にコードを書いてゲームを作る過程を学ぶことができます。

初心者でもわかりやすく解説しているので、プログラミングの楽しさを感じながら、ブラックジャックを自分の手で作ってみましょう。

目次から探す

ブラックジャックとは

ブラックジャックは、カジノで人気のあるカードゲームで、プレイヤーがディーラーに対して勝負を挑む形式のゲームです。

目標は、手札の合計が21に近づけることですが、21を超えてしまうと「バースト」となり、負けとなります。

このゲームは、運だけでなく戦略も重要で、プレイヤーは自分の手札とディーラーの見せ札を見ながら、ヒット(カードを引く)やスタンド(カードを引かない)を選択します。

ゲームの概要

ブラックジャックは通常、1人以上のプレイヤーと1人のディーラーで行われます。

ゲームは、52枚のトランプを使用して行われ、各プレイヤーには最初に2枚のカードが配られます。

ディーラーも同様にカードを受け取りますが、1枚は表向き、もう1枚は裏向きにします。

プレイヤーは、手札の合計が21に近づくようにカードを引くか、引かないかを選択し、最終的にディーラーと勝負します。

基本ルール

ブラックジャックの基本ルールは以下の通りです。

カードの価値:

数字カード(2〜10)はそのままの数字の価値を持ちます。
ジャック、クイーン、キングはそれぞれ10の価値を持ちます。
エースは1または11のいずれかの価値を持ち、プレイヤーが選択できます。

ゲームの流れ:

プレイヤーは賭け金を置き、ディーラーがカードを配ります。
プレイヤーは自分の手札を見て、ヒットまたはスタンドを選択します。
プレイヤーがスタンドを選んだ後、ディーラーのターンになります。

ディーラーは手札が17以上になるまでカードを引き続けます。

勝敗の決定:

プレイヤーの手札が21を超えた場合、バーストとなり自動的に負けです。
プレイヤーの手札がディーラーの手札よりも高い場合、プレイヤーの勝ちです。
ディーラーの手札が21を超えた場合、ディーラーがバーストとなりプレイヤーの勝ちです。
同点の場合は、引き分けとなります。

プレイヤーとディーラーの役割

ブラックジャックでは、プレイヤーとディーラーの役割が明確に分かれています。

プレイヤー:

プレイヤーは自分の手札を強化するために、ヒットやスタンドを選択します。

戦略的に判断し、ディーラーの見せ札を考慮しながら行動することが求められます。

プレイヤーは、勝つために最適な選択をする必要があります。

ディーラー:

ディーラーは、カジノのルールに従って行動します。

通常、ディーラーは手札が17以上になるまでカードを引き続けるというルールがあります。

ディーラーはプレイヤーに対して公平にゲームを進行させる役割を担っています。

このように、ブラックジャックはシンプルなルールながらも、戦略や心理戦が絡む奥深いゲームです。

次のセクションでは、プログラムの設計について詳しく見ていきましょう。

プログラムの設計

ブラックジャックのプログラムを設計する際には、ゲームの流れを明確にし、必要なデータ構造を定義することが重要です。

これにより、プログラムの実装がスムーズに進みます。

ゲームのフロー

ブラックジャックのゲームフローは以下のようになります。

ゲーム開始のメッセージを表示する。
カードデッキを作成し、シャッフルする。
プレイヤーとディーラーにそれぞれ2枚のカードを配る。
プレイヤーの手札を表示し、ヒットまたはスタンドの選択を促す。
プレイヤーがヒットを選んだ場合、カードを1枚引く。
プレイヤーがスタンドを選んだ場合、ディーラーのターンに移る。
ディーラーは自動的にカードを引き、手札の合計が17以上になるまで続ける。
勝敗を判定し、結果を表示する。
ゲームを続けるか終了するかを選択する。

このフローに従ってプログラムを構築することで、ゲームの進行が自然になります。

必要なデータ構造

プログラムを効率的に実装するためには、適切なデータ構造を定義する必要があります。

ここでは、カードとプレイヤーを表現するための構造体を作成します。

カードの構造体

カードを表現するための構造体を定義します。

カードにはスート(マーク)とランク(数字または絵札)が必要です。

// カードを表現する構造体
typedef struct {
    char suit;  // スート('H' = ハート, 'D' = ダイヤ, 'C' = クラブ, 'S' = スペード)
    int rank;   // ランク(1 = エース, 2-10 = 数字, 11 = ジャック, 12 = クイーン, 13 = キング)
} Card;

この構造体を使うことで、各カードの情報を簡単に管理できます。

プレイヤーの構造体

プレイヤーを表現するための構造体も必要です。

プレイヤーには手札とその合計点数を保持する必要があります。

// プレイヤーを表現する構造体
typedef struct {
    Card hand[12];  // プレイヤーの手札(最大12枚)
    int handSize;   // 手札の枚数
    int total;      // 手札の合計点数
} Player;

この構造体を使用することで、プレイヤーの手札や合計点数を簡単に管理し、ゲームの進行に応じて更新できます。

これらのデータ構造を定義することで、プログラムの実装がより明確になり、各機能を効率的に実装できるようになります。

次のステップでは、カードの生成と管理について詳しく見ていきます。

カードの生成と管理

ブラックジャックのゲームを実装するためには、まずカードデッキを作成し、シャッフルし、プレイヤーとディーラーにカードを配布する必要があります。

このセクションでは、これらのプロセスを詳しく説明します。

カードデッキの作成

カードデッキは、52枚のカードから構成されます。

各カードは、スート(ハート、ダイヤ、クラブ、スペード)とランク(2から10、J、Q、K、A)を持っています。

まず、カードを表現するための構造体を定義し、デッキを作成する関数を実装します。

以下は、カードとデッキを表現するための構造体の定義とデッキを作成する関数の例です。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define DECK_SIZE 52
// カードの構造体
typedef struct {
    char *suit; // スート
    char *rank; // ランク
} Card;
// デッキの構造体
typedef struct {
    Card cards[DECK_SIZE]; // カードの配列
    int top; // デッキの一番上のカードのインデックス
} Deck;
// デッキを作成する関数
void createDeck(Deck *deck) {
    char *suits[] = {"ハート", "ダイヤ", "クラブ", "スペード"};
    char *ranks[] = {"2", "3", "4", "5", "6", "7", "8", "9", "10", "J", "Q", "K", "A"};
    
    int index = 0;
    for (int i = 0; i < 4; i++) { // スートのループ
        for (int j = 0; j < 13; j++) { // ランクのループ
            deck->cards[index].suit = suits[i];
            deck->cards[index].rank = ranks[j];
            index++;
        }
    }
    deck->top = DECK_SIZE - 1; // デッキの一番上のカードを初期化
}

このコードでは、Card構造体がカードのスートとランクを持ち、Deck構造体がカードの配列とデッキの一番上のカードのインデックスを持っています。

createDeck関数は、デッキを作成し、各カードを適切に初期化します。

デッキのシャッフル

次に、作成したデッキをシャッフルします。

シャッフルは、カードの順序をランダムに入れ替えるプロセスです。

以下は、デッキをシャッフルする関数の例です。

// デッキをシャッフルする関数
void shuffleDeck(Deck *deck) {
    srand(time(NULL)); // 乱数の初期化
    for (int i = 0; i < DECK_SIZE; i++) {
        int j = rand() % DECK_SIZE; // 0からDECK_SIZE-1の乱数を生成
        // カードの入れ替え
        Card temp = deck->cards[i];
        deck->cards[i] = deck->cards[j];
        deck->cards[j] = temp;
    }
}

このshuffleDeck関数では、srandを使って乱数の初期化を行い、randを使ってカードのインデックスをランダムに選び、カードを入れ替えています。

これにより、デッキがランダムにシャッフルされます。

カードの配布

最後に、シャッフルされたデッキからプレイヤーとディーラーにカードを配布します。

通常、ブラックジャックでは、プレイヤーとディーラーにそれぞれ2枚のカードが配られます。

以下は、カードを配布する関数の例です。

// カードを配布する関数
void dealCards(Deck *deck, Card *playerHand, Card *dealerHand) {
    for (int i = 0; i < 2; i++) { // プレイヤーとディーラーに2枚ずつ配布
        playerHand[i] = deck->cards[deck->top--]; // プレイヤーにカードを配布
        dealerHand[i] = deck->cards[deck->top--]; // ディーラーにカードを配布
    }
}

このdealCards関数では、デッキの一番上のカードをプレイヤーとディーラーに配布し、デッキのインデックスを減少させています。

これにより、カードが配られた後のデッキの状態が更新されます。

以上で、カードの生成と管理に関する基本的な実装が完了しました。

次のセクションでは、プレイヤーの操作について詳しく見ていきます。

プレイヤーの操作

ブラックジャックでは、プレイヤーが自分の手札をどうするかを選択することが重要です。

このセクションでは、プレイヤーが「ヒット」または「スタンド」を選択する方法と、手札の合計を計算する方法について説明します。

ヒットとスタンドの選択

プレイヤーは、自分の手札の合計が21に近づくようにカードを引く「ヒット」か、これ以上カードを引かずにそのままの手札で勝負する「スタンド」を選択します。

以下は、ヒットとスタンドの選択を実装するためのサンプルコードです。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
// プレイヤーの手札の合計を計算する関数
int calculate_hand_value(int hand[], int hand_size) {
    int total = 0;
    int ace_count = 0;
    for (int i = 0; i < hand_size; i++) {
        total += hand[i];
        if (hand[i] == 1) { // エースのカウント
            ace_count++;
        }
    }
    // エースを11としてカウントできる場合、合計が21を超えないように調整
    while (total <= 11 && ace_count > 0) {
        total += 10; // エースを11としてカウント
        ace_count--;
    }
    return total;
}
// ヒットまたはスタンドを選択する関数
void player_turn(int hand[], int *hand_size) {
    char choice;
    while (1) {
        printf("ヒット(H)またはスタンド(S)を選択してください: ");
        scanf(" %c", &choice);
        if (choice == 'H' || choice == 'h') {
            // 新しいカードを引く処理(ここではダミーのカードを追加)
            hand[*hand_size] = rand() % 10 + 1; // 1から10のカードを引く
            (*hand_size)++;
            printf("新しいカードを引きました。手札の合計: %d\n", calculate_hand_value(hand, *hand_size));
            if (calculate_hand_value(hand, *hand_size) > 21) {
                printf("バーストしました！\n");
                break;
            }
        } else if (choice == 'S' || choice == 's') {
            printf("スタンドを選択しました。手札の合計: %d\n", calculate_hand_value(hand, *hand_size));
            break;
        } else {
            printf("無効な選択です。再度選択してください。\n");
        }
    }
}

このコードでは、プレイヤーがヒットまたはスタンドを選択するための関数 player_turn を定義しています。

プレイヤーがヒットを選択すると、ランダムに生成されたカードが手札に追加され、手札の合計が計算されます。

もし合計が21を超えた場合は「バースト」となり、ゲームが終了します。

プレイヤーの手札の合計計算

手札の合計を計算するためには、カードの値を合計し、エースの扱いを考慮する必要があります。

エースは1または11として扱うことができるため、合計が21を超えないように調整します。

上記のコードの calculate_hand_value関数がその役割を果たしています。

この関数では、手札の合計を計算し、エースの数をカウントします。

合計が11以下でエースが含まれている場合、エースを11としてカウントすることで、合計を最大限に活用します。

これにより、プレイヤーは最適な手札の合計を得ることができます。

このようにして、プレイヤーは自分の手札を管理し、戦略的にゲームを進めることができます。

次のセクションでは、ディーラーの操作について説明します。

ディーラーの操作

ブラックジャックにおいて、ディーラーは特定のルールに従って行動します。

プレイヤーがヒットやスタンドを選択した後、ディーラーのターンが始まります。

ここでは、ディーラーのヒットルールと手札の合計計算について詳しく解説します。

ディーラーのヒットルール

ディーラーは、手札の合計が一定の値以下である限り、カードを引く(ヒットする)必要があります。

一般的なルールでは、ディーラーは手札の合計が17未満の場合にヒットし、17以上の場合にはスタンドします。

このルールは、ゲームの公平性を保つために設けられています。

以下は、ディーラーのヒットルールを実装するためのサンプルコードです。

#include <stdio.h>
#define MAX_HAND 11 // 手札の最大枚数
// カードの構造体
typedef struct {
    int value; // カードの値
} Card;
// プレイヤーの構造体
typedef struct {
    Card hand[MAX_HAND]; // 手札
    int handSize; // 手札の枚数
} Player;
// 手札の合計を計算する関数
int calculateHandValue(Player *player) {
    int total = 0;
    int aceCount = 0;
    for (int i = 0; i < player->handSize; i++) {
        total += player->hand[i].value;
        if (player->hand[i].value == 1) { // エースの場合
            aceCount++;
        }
    }
    // エースを11として計算できる場合は調整
    while (total <= 11 && aceCount > 0) {
        total += 10; // エースを11に変更
        aceCount--;
    }
    return total;
}
// ディーラーの行動を決定する関数
void dealerAction(Player *dealer) {
    while (calculateHandValue(dealer) < 17) {
        // デッキからカードを引く処理をここに追加
        // 例: dealer->hand[dealer->handSize++] = drawCard();
        printf("ディーラーはヒットします。\n");
    }
    printf("ディーラーはスタンドします。\n");
}

このコードでは、calculateHandValue関数を使用してディーラーの手札の合計を計算し、合計が17未満であればヒットするようにしています。

ディーラーがヒットする際には、実際のカードをデッキから引く処理を追加する必要があります。

ディーラーの手札の合計計算

ディーラーの手札の合計を計算する方法は、プレイヤーの手札の合計を計算する方法とほぼ同じです。

エースの扱いに注意しながら、手札の合計を正確に計算することが重要です。

上記のcalculateHandValue関数は、ディーラーの手札の合計を計算するためにも使用できます。

この関数は、手札の各カードの値を合計し、エースが含まれている場合はその値を調整します。

ディーラーの手札の合計を計算することで、ディーラーがヒットするかスタンドするかの判断が可能になります。

これにより、ゲームの進行がスムーズになります。

このように、ディーラーの操作はブラックジャックのゲームにおいて非常に重要な要素です。

次のセクションでは、勝敗の判定について解説します。

勝敗の判定

ブラックジャックでは、ゲームの結果を判定するために、プレイヤーとディーラーの手札の合計値を比較します。

このセクションでは、勝敗のルールと結果の表示方法について詳しく解説します。

勝敗のルール

ブラックジャックの勝敗は、以下のルールに基づいて決まります。

バースト: プレイヤーまたはディーラーの手札の合計が21を超えた場合、そのプレイヤーはバーストとなり、負けとなります。
ブラックジャック: プレイヤーが最初の2枚のカードで合計が21(エースと10点カード)になった場合、ブラックジャックとなり、通常の勝利よりも高い配当が得られます。
合計の比較: プレイヤーとディーラーの手札の合計を比較します。

プレイヤーの合計がディーラーの合計よりも高い場合、プレイヤーの勝ち。
ディーラーの合計がプレイヤーの合計よりも高い場合、ディーラーの勝ち。
両者の合計が同じ場合は引き分けとなります。

これらのルールをプログラムに実装するために、勝敗を判定する関数を作成します。

// 勝敗を判定する関数
void judge_winner(Player player, Dealer dealer) {
    int player_total = calculate_hand_total(player.hand);
    int dealer_total = calculate_hand_total(dealer.hand);
    // バースト判定
    if (player_total > 21) {
        printf("プレイヤーはバーストしました。ディーラーの勝ちです。\n");
    } else if (dealer_total > 21) {
        printf("ディーラーはバーストしました。プレイヤーの勝ちです。\n");
    } else if (player_total == 21 && player.hand_size == 2) {
        printf("プレイヤーはブラックジャックです！プレイヤーの勝ちです。\n");
    } else if (player_total > dealer_total) {
        printf("プレイヤーの勝ちです！\n");
    } else if (player_total < dealer_total) {
        printf("ディーラーの勝ちです！\n");
    } else {
        printf("引き分けです。\n");
    }
}

この関数では、プレイヤーとディーラーの手札の合計を計算し、上記のルールに従って勝敗を判定します。

結果の表示

勝敗が判定された後、結果を表示することが重要です。

プレイヤーに対して、勝敗の結果をわかりやすく伝えるために、以下のようなメッセージを表示します。

// 結果を表示する関数
void display_result(Player player, Dealer dealer) {
    printf("プレイヤーの手札: ");
    display_hand(player.hand);
    printf("合計: %d\n", calculate_hand_total(player.hand));
    printf("ディーラーの手札: ");
    display_hand(dealer.hand);
    printf("合計: %d\n", calculate_hand_total(dealer.hand));
    // 勝敗判定を呼び出す
    judge_winner(player, dealer);
}

この関数では、プレイヤーとディーラーの手札を表示し、それぞれの合計を示した後、勝敗を判定する関数を呼び出します。

これにより、プレイヤーは自分の手札とディーラーの手札を確認し、結果を理解しやすくなります。

以上のように、勝敗の判定と結果の表示を行うことで、ブラックジャックのゲームがよりスムーズに進行し、プレイヤーにとっても楽しめる体験となります。

プログラムの実装

ブラックジャックのプログラムを実装するためには、まず全体の構成を理解し、各機能を持つ関数を作成する必要があります。

以下に、プログラムの全体構成と各関数の実装方法を詳しく説明します。

コードの全体構成

プログラムは以下のような構成になります。

必要なライブラリのインクルード
データ構造の定義
関数のプロトタイプ宣言
メイン関数
各機能を持つ関数の実装

この構成に従って、プログラムを作成していきます。

各関数の実装

メイン関数

メイン関数では、ゲームの流れを制御します。

プレイヤーとディーラーの初期化、カードの配布、プレイヤーの操作、ディーラーの操作、勝敗の判定を行います。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX_CARDS 52
#define MAX_PLAYERS 1
#define BLACKJACK 21
typedef struct {
    int value; // カードの値
    char suit; // カードのスート
} Card;
typedef struct {
    Card hand[10]; // プレイヤーの手札
    int handSize; // 手札の枚数
} Player;
// プロトタイプ宣言
void initializeDeck(Card deck[]);
void shuffleDeck(Card deck[]);
void dealCard(Card deck[], Player *player, int *deckIndex);
int calculateHandValue(Player *player);
void playerTurn(Player *player, Card deck[], int *deckIndex);
void dealerTurn(Player *dealer, Card deck[], int *deckIndex);
void determineWinner(Player *player, Player *dealer);
int main() {
    Card deck[MAX_CARDS];
    Player player = { .handSize = 0 };
    Player dealer = { .handSize = 0 };
    int deckIndex = 0;
    srand(time(NULL)); // 乱数の初期化
    initializeDeck(deck); // デッキの初期化
    shuffleDeck(deck); // デッキのシャッフル
    // カードの配布
    for (int i = 0; i < 2; i++) {
        dealCard(deck, &player, &deckIndex);
        dealCard(deck, &dealer, &deckIndex);
    }
    // プレイヤーのターン
    playerTurn(&player, deck, &deckIndex);
    // ディーラーのターン
    dealerTurn(&dealer, deck, &deckIndex);
    // 勝敗の判定
    determineWinner(&player, &dealer);
    return 0;
}

カード生成関数

カードの生成と初期化を行う関数です。

void initializeDeck(Card deck[]) {
    char suits[] = {'H', 'D', 'C', 'S'}; // ハート、ダイヤ、クラブ、スペード
    int index = 0;
    for (int i = 0; i < 4; i++) { // スートのループ
        for (int j = 1; j <= 13; j++) { // 1から13までのカード
            deck[index].value = (j > 10) ? 10 : j; // 11, 12, 13は10として扱う
            deck[index].suit = suits[i];
            index++;
        }
    }
}

プレイヤー操作関数

プレイヤーがヒットまたはスタンドを選択するための関数です。

void playerTurn(Player *player, Card deck[], int *deckIndex) {
    char choice;
    while (1) {
        printf("手札の合計: %d\n", calculateHandValue(player));
        printf("ヒットしますか？ (y/n): ");
        scanf(" %c", &choice);
        if (choice == 'y') {
            dealCard(deck, player, deckIndex);
            if (calculateHandValue(player) > BLACKJACK) {
                printf("バーストしました！\n");
                break;
            }
        } else {
            break;
        }
    }
}

ディーラー操作関数

ディーラーのターンを制御する関数です。

ディーラーは手札の合計が17未満の場合、ヒットします。

void dealerTurn(Player *dealer, Card deck[], int *deckIndex) {
    while (calculateHandValue(dealer) < 17) {
        dealCard(deck, dealer, deckIndex);
    }
}

勝敗判定関数

プレイヤーとディーラーの手札を比較し、勝敗を判定する関数です。

void determineWinner(Player *player, Player *dealer) {
    int playerValue = calculateHandValue(player);
    int dealerValue = calculateHandValue(dealer);
    printf("プレイヤーの手札の合計: %d\n", playerValue);
    printf("ディーラーの手札の合計: %d\n", dealerValue);
    if (playerValue > BLACKJACK) {
        printf("プレイヤーの負けです。\n");
    } else if (dealerValue > BLACKJACK || playerValue > dealerValue) {
        printf("プレイヤーの勝ちです！\n");
    } else if (playerValue < dealerValue) {
        printf("プレイヤーの負けです。\n");
    } else {
        printf("引き分けです。\n");
    }
}

完成したコード

以上の関数を組み合わせることで、ブラックジャックの基本的なプログラムが完成します。

以下に、全体のコードをまとめます。

#include <stdio.h>
#include <stdlib.h>
#include <time.h>
#define MAX_CARDS 52
#define MAX_PLAYERS 1
#define BLACKJACK 21
typedef struct {
    int value; // カードの値
    char suit; // カードのスート
} Card;
typedef struct {
    Card hand[10]; // プレイヤーの手札
    int handSize; // 手札の枚数
} Player;
// プロトタイプ宣言
void initializeDeck(Card deck[]);
void shuffleDeck(Card deck[]);
void dealCard(Card deck[], Player *player, int *deckIndex);
int calculateHandValue(Player *player);
void playerTurn(Player *player, Card deck[], int *deckIndex);
void dealerTurn(Player *dealer, Card deck[], int *deckIndex);
void determineWinner(Player *player, Player *dealer);
int main() {
    Card deck[MAX_CARDS];
    Player player = { .handSize = 0 };
    Player dealer = { .handSize = 0 };
    int deckIndex = 0;
    srand(time(NULL)); // 乱数の初期化
    initializeDeck(deck); // デッキの初期化
    shuffleDeck(deck); // デッキのシャッフル
    // カードの配布
    for (int i = 0; i < 2; i++) {
        dealCard(deck, &player, &deckIndex);
        dealCard(deck, &dealer, &deckIndex);
    }
    // プレイヤーのターン
    playerTurn(&player, deck, &deckIndex);
    // ディーラーのターン
    dealerTurn(&dealer, deck, &deckIndex);
    // 勝敗の判定
    determineWinner(&player, &dealer);
    return 0;
}
void initializeDeck(Card deck[]) {
    char suits[] = {'H', 'D', 'C', 'S'}; // ハート、ダイヤ、クラブ、スペード
    int index = 0;
    for (int i = 0; i < 4; i++) { // スートのループ
        for (int j = 1; j <= 13; j++) { // 1から13までのカード
            deck[index].value = (j > 10) ? 10 : j; // 11, 12, 13は10として扱う
            deck[index].suit = suits[i];
            index++;
        }
    }
}
void shuffleDeck(Card deck[]) {
    for (int i = 0; i < MAX_CARDS; i++) {
        int j = rand() % MAX_CARDS;
        Card temp = deck[i];
        deck[i] = deck[j];
        deck[j] = temp;
    }
}
void dealCard(Card deck[], Player *player, int *deckIndex) {
    player->hand[player->handSize] = deck[*deckIndex];
    player->handSize++;
    (*deckIndex)++;
}
int calculateHandValue(Player *player) {
    int value = 0;
    int aceCount = 0;
    for (int i = 0; i < player->handSize; i++) {
        value += player->hand[i].value;
        if (player->hand[i].value == 1) { // エースのカウント
            aceCount++;
        }
    }
    // エースを11として扱う場合の調整
    while (value <= 11 && aceCount > 0) {
        value += 10;
        aceCount--;
    }
    return value;
}
void playerTurn(Player *player, Card deck[], int *deckIndex) {
    char choice;
    while (1) {
        printf("手札の合計: %d\n", calculateHandValue(player));
        printf("ヒットしますか？ (y/n): ");
        scanf(" %c", &choice);
        if (choice == 'y') {
            dealCard(deck, player, deckIndex);
            if (calculateHandValue(player) > BLACKJACK) {
                printf("バーストしました！\n");
                break;
            }
        } else {
            break;
        }
    }
}
void dealerTurn(Player *dealer, Card deck[], int *deckIndex) {
    while (calculateHandValue(dealer) < 17) {
        dealCard(deck, dealer, deckIndex);
    }
}
void determineWinner(Player *player, Player *dealer) {
    int playerValue = calculateHandValue(player);
    int dealerValue = calculateHandValue(dealer);
    printf("プレイヤーの手札の合計: %d\n", playerValue);
    printf("ディーラーの手札の合計: %d\n", dealerValue);
    if (playerValue > BLACKJACK) {
        printf("プレイヤーの負けです。\n");
    } else if (dealerValue > BLACKJACK || playerValue > dealerValue) {
        printf("プレイヤーの勝ちです！\n");
    } else if (playerValue < dealerValue) {
        printf("プレイヤーの負けです。\n");
    } else {
        printf("引き分けです。\n");
    }
}

このコードを実行することで、コンソール上でブラックジャックを楽しむことができます。

プレイヤーはヒットまたはスタンドを選択し、ディーラーとの勝負を楽しむことができます。

デバッグとテスト

プログラムを作成した後は、必ずデバッグとテストを行うことが重要です。

これにより、プログラムが正しく動作するかどうかを確認し、潜在的なバグを見つけて修正することができます。

ここでは、エラーチェックとテストケースの作成について詳しく説明します。

エラーチェック

エラーチェックは、プログラムが予期しない動作をしないようにするための重要なプロセスです。

ブラックジャックのプログラムにおいては、以下のようなエラーチェックを行うことが考えられます。

入力の検証: プレイヤーがヒットまたはスタンドを選択する際に、無効な入力(例えば、数字以外の文字や範囲外の数値)がないかを確認します。

これには、scanfの戻り値をチェックすることが有効です。

カードの配布の確認: カードを配布する際に、デッキに残っているカードの数を確認し、カードが不足していないかをチェックします。
手札の合計の計算: プレイヤーやディーラーの手札の合計が正しく計算されているかを確認します。

特に、エースの扱い(1または11)に注意が必要です。

以下は、入力の検証を行うためのサンプルコードです。

#include <stdio.h>
int getPlayerChoice() {
    int choice;
    printf("ヒット(1)またはスタンド(2)を選択してください: ");
    while (scanf("%d", &choice) != 1 || (choice != 1 && choice != 2)) {
        printf("無効な入力です。ヒット(1)またはスタンド(2)を選択してください: ");
        while (getchar() != '\n'); // 入力バッファをクリア
    }
    return choice;
}

このコードでは、プレイヤーの入力が1または2であることを確認し、無効な入力があった場合は再度入力を促します。

テストケースの作成

テストケースは、プログラムの各機能が正しく動作するかを確認するための具体的なシナリオです。

ブラックジャックのプログラムにおいては、以下のようなテストケースを考えることができます。

基本的なゲームフローのテスト:

プレイヤーがヒットを選択した場合、手札が正しく更新されるか。
プレイヤーがスタンドを選択した場合、次のターンに進むか。

勝敗判定のテスト:

プレイヤーが21を超えた場合、負けるか。
プレイヤーとディーラーの手札が同じ場合、引き分けになるか。

エッジケースのテスト:

デッキが空になった場合、プログラムが適切にエラーメッセージを表示するか。
プレイヤーがエースを持っている場合、手札の合計が正しく計算されるか。

以下は、勝敗判定のテストを行うためのサンプルコードです。

#include <stdio.h>
void testWinCondition(int playerTotal, int dealerTotal) {
    if (playerTotal > 21) {
        printf("プレイヤーはバーストしました。負けです。\n");
    } else if (dealerTotal > 21) {
        printf("ディーラーはバーストしました。勝ちです。\n");
    } else if (playerTotal > dealerTotal) {
        printf("プレイヤーの勝ちです。\n");
    } else if (playerTotal < dealerTotal) {
        printf("ディーラーの勝ちです。\n");
    } else {
        printf("引き分けです。\n");
    }
}

この関数は、プレイヤーとディーラーの手札の合計を受け取り、勝敗を判定します。

テストケースを実行することで、プログラムの動作が期待通りであることを確認できます。

デバッグとテストは、プログラムの品質を向上させるために欠かせないプロセスです。

しっかりと行うことで、より信頼性の高いブラックジャックプログラムを作成することができます。