C++で学ぶ当たり判定の全て！10のサンプルコードで徹底解説

はじめに
●C++とは
- ○C++の基本
- ○C++の特徴と利点
●当たり判定の基礎
- ○当たり判定の重要性
- ○当たり判定の種類と原理
●C++における当たり判定の基本
- ○サンプルコード1：単純な衝突検知
- ○サンプルコード2：距離ベースの当たり判定
●当たり判定の詳細な使い方
●当たり判定の応用例
●当たり判定の詳細な対処法と注意点
- ○注意点：性能最適化と安定性
- ○対処法：一般的なエラーとその解決策
●当たり判定のカスタマイズ方法
- ○サンプルコード9：ユーザー入力に基づく当たり判定のカスタマイズ
- ○サンプルコード10：動的な環境での当たり判定の調整
まとめ

はじめに

この記事では、C++における当たり判定の基本から応用、カスタマイズ方法までを、10のサンプルコードを通じて徹底解説します。

C++での当たり判定は、ゲーム開発やシミュレーション、さまざまなプログラミングプロジェクトで不可欠な要素です。

本記事を読めば、C++における当たり判定の全体像を理解し、実際にコードを書く際の実践的な知識が身につきます。

●C++とは

C++は、中級レベルから上級レベルのプログラミング言語で、高いパフォーマンスと柔軟性を兼ね備えています。

C言語の上位互換として開発されたC++は、オブジェクト指向プログラミング、ジェネリックプログラミング、関数型プログラミングといった多様なプログラミングパラダイムをサポートしています。

これにより、ゲーム開発、システムプログラミング、アプリケーション開発など、幅広い分野で利用されています。

○C++の基本

C++を学ぶには、まずその基本構文と概念を理解することが重要です。

C++は、変数、関数、データ型、オペレータなどの基本的なプログラミング要素から構成されています。

また、オブジェクト指向の特徴を活かしたクラスとオブジェクト、継承、多態性などの概念もC++の重要な要素です。

これらの基本的な要素を理解することで、より複雑なプログラミングタスクに取り組む準備ができます。

○C++の特徴と利点

C++の最大の特徴は、そのパフォーマンスの高さと柔軟性です。

コンパイル言語であるため実行速度が速く、システムレベルのプログラミングに適しています。

また、メモリ管理を細かくコントロールできるため、リソースが限られた環境での開発にも向いています。

オブジェクト指向の特性を活かし、再利用可能なコードを書くことで開発の効率化を図れるのも大きな利点です。

さらに、豊富なライブラリとコミュニティのサポートにより、さまざまなプロジェクトでの使用が容易になっています。

●当たり判定の基礎

C++における当たり判定は、プログラミングにおいて非常に重要な概念です。

これは、オブジェクトが互いに接触しているかどうかを判断するプロセスです。

ゲーム開発、物理シミュレーション、ユーザーインターフェースの設計など、多岐にわたる分野で応用されています。

当たり判定は、単純な衝突検知から複雑な相互作用まで、様々な形で使用されます。

プログラム内で物体が接触しているかを判定するためには、物体の形状、位置、移動の軌跡など、様々な要素を計算に入れなければなりません。

C++では、これらの要素を効率的に処理し、正確な当たり判定を実現するために、様々なアルゴリズムとデータ構造が使用されます。

○当たり判定の重要性

当たり判定は、プログラムにおいてオブジェクト間の相互作用を決定するために不可欠です。

例えば、ゲームにおいてプレイヤーのキャラクターが敵に接触したかどうかを判定する際、正確な当たり判定が必要となります。

これにより、ゲームのリアリズムと応答性が大きく向上します。

当たり判定は、単にオブジェクトが他のオブジェクトに接触しているかどうかを検知するだけではなく、その接触の程度や影響も考慮する必要があります。

これは、物理ベースのゲームやシミュレーションにおいて特に重要です。

例えば、車両のシミュレーションでは、衝突の強さに応じてダメージを計算する必要があります。

○当たり判定の種類と原理

当たり判定にはいくつかの基本的なタイプがあります。

最も単純な形態は、点対点の衝突検知です。

これは、二つのオブジェクトの特定の点が互いに一定の距離内にあるかどうかを確認するものです。

これは非常に効率的ですが、より複雑な形状や動きには適していません。

より高度な形態の一つに、境界ボックスを使用した衝突検知があります。

この方法では、オブジェクトを囲む矩形または立方体（境界ボックス）を計算し、これらのボックスが互いに重なるかどうかをチェックします。

この方法は多くのビデオゲームで使われており、より複雑な形状のオブジェクトにも対応可能です。

さらに複雑な方法としては、形状ベースの衝突検知があります。

これは、オブジェクトの具体的な形状を考慮に入れ、より精密な衝突検知を行います。

この方法は計算コストが高いですが、リアリティと正確性を求めるアプリケーションには不可欠です。

例えば、複雑な3Dモデルを持つゲームや、高度な物理シミュレーションではこの方法が用いられます。

●C++における当たり判定の基本

C++において当たり判定の基本を理解することは、効果的なプログラミングにとって欠かせないスキルです。

当たり判定は、オブジェクト間の相互作用を検出し、応答するためのプロセスです。

ゲーム開発、シミュレーション、ユーザーインターフェース設計など、多くの分野でこの技術が必要とされます。

C++での当たり判定の実装は、オブジェクトの形状、大きさ、位置などの情報を利用します。

これらの情報に基づいて、プログラムはオブジェクトが他のオブジェクトと接触しているかどうかを計算し、必要に応じて特定のアクションを起こすことができます。

このプロセスは、物理的な現実を模倣するために重要であり、ユーザーにとって直感的でリアルな体験を提供するために不可欠です。

○サンプルコード1：単純な衝突検知

単純な衝突検知の例として、二つの円形オブジェクトが接触しているかどうかを判定するC++のコードを考えてみましょう。

ここでは、各円の中心の座標と半径を使用して、二つの円が重なっているかを判断します。

これは、二つの円の中心間の距離が両円の半径の合計より小さい場合、衝突していると判断するという原理に基づいています。

#include <iostream>
#include <cmath>

struct Circle {
    double x, y, radius;
};

bool isColliding(const Circle& c1, const Circle& c2) {
    double distance = std::sqrt((c1.x - c2.x) * (c1.x - c2.x) + (c1.y - c2.y) * (c1.y - c2.y));
    return distance < (c1.radius + c2.radius);
}

int main() {
    Circle circle1 = {0, 0, 5};
    Circle circle2 = {4, 3, 2};

    if (isColliding(circle1, circle2)) {
        std::cout << "衝突しています。" << std::endl;
    } else {
        std::cout << "衝突していません。" << std::endl;
    }

    return 0;
}

このコードでは、Circle構造体を定義しており、それぞれの円の中心の座標（x, y）と半径を保持しています。

isColliding関数は、二つの円が衝突しているかどうかを計算し、衝突している場合はtrueを返します。

○サンプルコード2：距離ベースの当たり判定

距離ベースの当たり判定は、オブジェクト間の距離を計算し、その距離が特定の閾値以下であるかどうかによって、衝突を検出します。

この方法は、特にオブジェクトが大きな空間に分散している場合や、シンプルな形状のオブジェクトに対して効果的です。

ここでは、二点間の距離を計算するシンプルなC++の関数を紹介します。

この関数は、二点の座標を受け取り、それらの間のユークリッド距離を返します。

#include <iostream>
#include <cmath>

double distance(double x1, double y1, double x2, double y2) {
    return std::sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1));
}

int main() {
    double x1 = 1, y1 = 2;
    double x2 = 4, y2 = 6;

    double dist = distance(x1, y1, x2, y2);
    std::cout << "二点間の距離は " << dist << " です。" << std::endl;

    return 0;
}

この例では、distance関数を使って二点間の距離を計算しています。

このような基本的な機能は、より複雑な当たり判定アルゴリズムの基礎となります。

●当たり判定の詳細な使い方

C++における当たり判定の応用は多岐にわたりますが、ここでは特に四角形、円形、多角形の当たり判定に焦点を当てます。

これらの形状はゲーム開発やシミュレーションなどで頻繁に使用されるため、これらの形状に対する効果的な当たり判定の方法を理解することは重要です。

○サンプルコード3：四角形の当たり判定

四角形の当たり判定は、通常、軸平行境界ボックス（Axis-Aligned Bounding Box, AABB）を使用して行われます。

AABBは四角形の各辺が座標軸に平行である四角形で、オブジェクトを包含する最小の矩形です。

四角形が他の四角形と衝突しているかどうかを判定するためには、これらのボックスが重なっているかどうかを確認します。

#include <iostream>

struct Rectangle {
    double x, y, width, height;
};

bool isColliding(const Rectangle& rect1, const Rectangle& rect2) {
    if (rect1.x < rect2.x + rect2.width && rect1.x + rect1.width > rect2.x &&
        rect1.y < rect2.y + rect2.height && rect1.y + rect1.height > rect2.y) {
        return true;
    }
    return false;
}

int main() {
    Rectangle rect1 = {0, 0, 3, 2};
    Rectangle rect2 = {1, 1, 3, 2};

    if (isColliding(rect1, rect2)) {
        std::cout << "衝突しています。" << std::endl;
    } else {
        std::cout << "衝突していません。" << std::endl;
    }

    return 0;
}

このコードでは、Rectangle構造体を使用して四角形を定義し、isColliding関数で二つの四角形が重なっているかどうかを判断しています。

○サンプルコード4：円形の当たり判定

円形の当たり判定は、円の中心間の距離とそれぞれの半径を比較することで行います。

二つの円の中心間の距離が、それぞれの半径の和よりも小さい場合、これらの円は互いに衝突していると見なされます。

#include <iostream>
#include <cmath>

struct Circle {
    double x, y, radius;
};

bool isColliding(const Circle& c1, const Circle& c2) {
    double distance = std::sqrt((c1.x - c2.x) * (c1.x - c2.x) + (c1.y - c2.y) * (c1.y - c2.y));
    return distance < (c1.radius + c2.radius);
}

int main() {
    Circle circle1 = {0, 0, 5};
    Circle circle2 = {4, 3, 2};

    if (isColliding(circle1, circle2)) {
        std::cout << "衝突しています。" << std::endl;
    } else {
        std::cout << "衝突していません。" << std::endl;
    }

    return 0;
}

このコード例では、Circle構造体を使って円を表し、isColliding関数で二つの円が衝突しているかどうかを計算しています。

○サンプルコード5：多角形の当たり判定

多角形の当たり判定は、一般に「分離軸定理（Separating Axis Theorem, SAT）」を用いて行われます。

この定理は、二つの凸多角形が衝突していない場合、それらを分離する軸が存在するというものです。

分離軸が見つからない場合、多角形は衝突していると判断されます。

ここでは、単純な多角形の当たり判定のためのC++サンプルコードを紹介します。

この例では、多角形を構成する頂点のリストを扱い、分離軸を見つけるための複数のステップを実行しています。

#include <iostream>
#include <vector>
#include <cmath>

struct Point {
    double x, y;
};

using Polygon = std::vector<Point>;

double dot(const Point& a, const Point& b) {
    return a.x * b.x + a.y * b.y;
}

Point edgeVector(const Point& a, const Point& b) {
    return {b.x - a.x, b.y - a.y};
}

Point normalVector(const Point& edge) {
    return {-edge.y, edge.x};
}

bool isSeparated(const Polygon& poly1, const Polygon& poly2, const Point& axis) {
    double min1 = std::numeric_limits<double>::infinity(), max1 = -min1;
    double min2 = min1, max2 = -min1;

    for (const auto& p : poly1) {
        double projection = dot(p, axis);
        min1 = std::min(min1, projection);
        max1 = std::max(max1, projection);
    }

    for (const auto& p : poly2) {
        double projection = dot(p, axis);
        min2 = std::min(min2, projection);
        max2 = std::max(max2, projection);
    }

    return max1 < min2 || max2 < min1;
}

bool polygonsCollide(const Polygon& poly1, const Polygon& poly2) {
    for (size_t i = 0; i < poly1.size(); i++) {
        Point edge = edgeVector(poly1[i], poly1[(i + 1) % poly1.size()]);
        Point axis = normalVector(edge);
        if (isSeparated(poly1, poly2, axis)) return false;
    }

    for (size_t i = 0; i < poly2.size(); i++) {
        Point edge = edgeVector(poly2[i], poly2[(i + 1) % poly2.size()]);
        Point axis = normalVector(edge);
        if (isSeparated(poly1, poly2, axis)) return false;
    }

    return true;
}

int main() {
    Polygon poly1 = {{0, 0}, {4, 0}, {2, 4}};
    Polygon poly2 = {{5, 5}, {9, 5}, {7, 9}};

    if (polygonsCollide(poly1, poly2)) {
        std::cout << "多角形は衝突しています。" << std::endl;
    } else {
        std::cout << "多角形は衝突していません。" << std::endl;
    }

    return 0;
}

このコードでは、各多角形に対してその全ての辺を調べ、それに垂直な軸（分離軸）に沿って多角形を射影しています。

この射影を使って二つの多角形が重なっていないかを確認します。どの軸においても重なりが見つからない場合、二つの多角形は衝突していないと判断されます。

●当たり判定の応用例

当たり判定の技術は、ゲーム開発、物理シミュレーション、インタラクティブアプリケーションなど、さまざまな分野で広く応用されています。

ここでは、これらの分野での当たり判定の実際の応用例を見ていきます。

○サンプルコード6：ゲームにおける当たり判定

ゲーム開発における当たり判定は、プレイヤーのアクションやオブジェクトの相互作用を実現する上で重要な役割を果たします。

例えば、プレイヤーキャラクターが敵に接触したかどうかを判断し、それに応じた反応をゲームに反映させる必要があります。

#include <iostream>
#include <vector>

struct Sprite {
    int x, y;
    int width, height;
};

bool checkCollision(const Sprite& sprite1, const Sprite& sprite2) {
    if (sprite1.x < sprite2.x + sprite2.width &&
        sprite1.x + sprite1.width > sprite2.x &&
        sprite1.y < sprite2.y + sprite2.height &&
        sprite1.height + sprite1.y > sprite2.y) {
        return true;
    }
    return false;
}

int main() {
    Sprite player = {100, 100, 20, 20};
    Sprite enemy = {120, 100, 20, 20};

    if (checkCollision(player, enemy)) {
        std::cout << "プレイヤーが敵と衝突しました。" << std::endl;
    } else {
        std::cout << "衝突はありません。" << std::endl;
    }

    return 0;
}

このサンプルコードでは、Sprite構造体を使用してゲーム内のキャラクターやオブジェクトを表現し、checkCollision関数で衝突判定を行います。

○サンプルコード7：物理シミュレーションにおける当たり判定

物理シミュレーションでは、オブジェクトの衝突に基づいて物理的な動作や反応を計算する必要があります。

下記のコードでは、簡単な物理シミュレーションにおける衝突判定を表しています。

// このコードは物理シミュレーションを行う上での基本的な枠組みを表すものであり、
// 物理エンジンの実装には更に多くの考慮が必要です。

#include <iostream>
#include <cmath>

struct Ball {
    double x, y;
    double radius;
};

bool isColliding(const Ball& ball1, const Ball& ball2) {
    double distance = std::sqrt((ball1.x - ball2.x) * (ball1.x - ball2.x) +
                                (ball1.y - ball2.y) * (ball1.y - ball2.y));
    return distance < (ball1.radius + ball2.radius);
}

int main() {
    Ball ball1 = {0, 0, 5};
    Ball ball2 = {3, 4, 5};

    if (isColliding(ball1, ball2)) {
        std::cout << "ボールが衝突しました。" << std::endl;
    } else {
        std::cout << "ボールは衝突していません。" << std::endl;
    }

    return 0;
}

この例では、2つのボールが衝突しているかどうかを判定しています。

物理シミュレーションでは、衝突後のオブジェクトの動きを計算するために、さらに詳細な物理計算が必要です。

○サンプルコード8：インタラクティブアプリケーションの当たり判定

インタラクティブアプリケーション、特にユーザーインターフェイスでは、ユーザーの入力に基づいた当たり判定が必要となります。

例えば、ユーザーが画面上のボタンをクリックしたかどうかを検出する必要があります。

#include <iostream>

struct Button {
    int x, y;
    int width, height;
};

bool isClicked(const Button& button, int mouseX, int mouseY) {
    return mouseX > button.x && mouseX < button.x + button.width &&
           mouseY > button.y && mouseY < button.y + button.height;
}

int main() {
    Button button = {100, 100, 50, 30};
    int mouseX = 110, mouseY = 115; // マウスの座標を想定

    if (isClicked(button, mouseX, mouseY)) {
        std::cout << "ボタンがクリックされました。" << std::endl;
    } else {
        std::cout << "クリックされていません。" << std::endl;
    }

    return 0;
}

このサンプルコードでは、Button構造体を使用して画面上のボタンを表現し、isClicked関数でユーザーがそのボタンをクリックしたかどうかを判定しています。

●当たり判定の詳細な対処法と注意点

当たり判定の実装においては、特に性能と安定性を確保することが重要です。

効率的でない当たり判定の処理は、特に多くのオブジェクトが関与する場面で、アプリケーション全体のパフォーマンスに悪影響を及ぼす可能性があります。

また、不安定な当たり判定アルゴリズムは、予期しないバグや問題の原因となり得ます。

そのため、当たり判定アルゴリズムの選定と実装には慎重なアプローチが求められます。

性能最適化においては、オブジェクト間での不必要な当たり判定計算を減らすための工夫が必要です。

例えば、空間分割やオブジェクトのグルーピングを利用することで、効率的な判定を行うことができます。

一方、安定性の確保においては、アルゴリズムのロジックを検証し、多様なテストケースに基づいて厳密なテストを実施することが重要です。

○注意点：性能最適化と安定性

性能の最適化と安定性の確保は、当たり判定のシステムを設計する上での主要な懸念事項です。

適切なアルゴリズムを選択し、アプリケーションの要件に合わせて適切に調整することが不可欠です。

特に、複雑なシーンや大量のオブジェクトが存在する状況では、これらの要素はパフォーマンスに大きな影響を与える可能性があります。

○対処法：一般的なエラーとその解決策

当たり判定のシステムにおいては、さまざまなエラーが生じうるため、それらに対する適切な対処法を理解しておくことが重要です。

誤った当たり判定や計算コストの過大化、不安定な挙動などの問題は、アルゴリズムの見直し、効率的な計算手法の導入、エッジケースに対する詳細なテストなどを通じて解決することができます。

これらの問題を適切に対処することで、高性能で安定した当たり判定システムを構築することが可能となります。

●当たり判定のカスタマイズ方法

当たり判定のカスタマイズは、特定のアプリケーションのニーズに合わせて当たり判定のアルゴリズムを調整することを指します。

このプロセスでは、ゲームのルールや物理の法則、ユーザーのインタラクションなど、さまざまな要素を考慮に入れる必要があります。

カスタマイズの目的は、よりリアルな体験を提供することや、特定のゲームプレイのメカニズムを強化することにあります。

○サンプルコード9：ユーザー入力に基づく当たり判定のカスタマイズ

インタラクティブなアプリケーションでは、ユーザーの入力に応じて動的に当たり判定を変更する必要があります。

例えば、ユーザーが画面上の特定のエリアをタッチまたはクリックすると、当たり判定の範囲を変更するような場合です。

#include <iostream>

struct Rectangle {
    int x, y, width, height;
};

bool isInside(const Rectangle& rect, int pointX, int pointY) {
    return pointX >= rect.x && pointX <= rect.x + rect.width &&
           pointY >= rect.y && pointY <= rect.y + rect.height;
}

int main() {
    Rectangle touchArea = {50, 50, 100, 100};
    int userInputX, userInputY;

    std::cout << "タッチ座標を入力してください（X Y）: ";
    std::cin >> userInputX >> userInputY;

    if (isInside(touchArea, userInputX, userInputY)) {
        std::cout << "タッチ領域内です。" << std::endl;
    } else {
        std::cout << "タッチ領域外です。" << std::endl;
    }

    return 0;
}

このコードでは、ユーザーが指定した座標が特定の領域内かどうかを判定します。

このようなカスタマイズにより、ユーザーのアクションに基づいて動的なフィードバックを提供できます。

○サンプルコード10：動的な環境での当たり判定の調整

動的な環境では、環境の変化に応じて当たり判定を調整する必要があります。

例えば、ゲーム内でオブジェクトが移動したり、形状が変わったりする場合、当たり判定もリアルタイムで更新する必要があります。

#include <iostream>

struct MovingObject {
    int x, y;
    int width, height;
    int velocityX, velocityY;
};

void updatePosition(MovingObject& obj) {
    obj.x += obj.velocityX;
    obj.y += obj.velocityY;
}

bool isColliding(const MovingObject& obj1, const MovingObject& obj2) {
    return obj1.x < obj2.x + obj2.width && obj1.x + obj1.width > obj2.x &&
           obj1.y < obj2.y + obj2.height && obj1.y + obj1.height > obj2.y;
}

int main() {
    MovingObject player = {10, 10, 30, 30, 5, 0};
    MovingObject enemy = {100, 10, 30, 30, -5, 0};

    updatePosition(player);
    updatePosition(enemy);

    if (isColliding(player, enemy)) {
        std::cout << "プレイヤーが敵と衝突しました。" << std::endl;
    } else {
        std::cout << "衝突はありません。" << std::endl;
    }

    return 0;
}

このコードは、動くオブジェクト同士の当たり判定をシミュレートします。

オブジェクトの位置は各フレームごとに更新され、その新しい位置で衝突判定が行われます。

このような方法で、動的な環境においても正確な当たり判定を実現できます。