モダン第12章：【C++20】コルーチン（Coroutines）による非同期ゲームループ

#include <iostream>
#include <coroutine>

// 最小限のコルーチン戻り値型（Task）
struct SimpleTask {
    struct promise_type {
        SimpleTask get_return_object() {
            return SimpleTask{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_never initial_suspend() noexcept { return {}; } // 呼び出し時に即開始
        std::suspend_always final_suspend() noexcept { return {}; }   // 終了時に中断保持
        void return_void() noexcept {}
        void unhandled_exception() { std::terminate(); }
    };

    std::coroutine_handle<promise_type> handle;
    ~SimpleTask() {
        if (handle) handle.destroy();
    }
};

// 一時停止（Suspend）を明示的に要求するカスタム Awaiter
struct SuspendPoint {
    bool await_ready() const noexcept { return false; } // 常に中断
    void await_suspend(std::coroutine_handle<>) const noexcept {}
    void await_resume() const noexcept {}
};

// コルーチン関数（内部に co_await があるため自動的にコルーチンとしてコンパイルされる）
SimpleTask bossSequence(std::coroutine_handle<>& outHandle) {
    std::cout << "[Step 1] ボス出現！警告アラート吹鳴！\n";
    co_await SuspendPoint{}; // ここで中断して呼び出し元に戻る！

    std::cout << "[Step 2] チャージ完了！ハイパーメガ粒子砲発射！\n";
    co_await SuspendPoint{}; // 再び中断

    std::cout << "[Step 3] シールド展開！第2フェーズ突入！\n";
}

int main() {
    std::cout << "--- メインループ開始 ---\n";
    std::coroutine_handle<> handle;
    
    // コルーチンを起動
    bossSequence(handle);

    std::cout << "--- メインループ：自機移動・描画などの通常フレーム実行中 ---\n";

    // 外側のゲームループから任意のタイミングで再開（resume）可能！
    return 0;
}

#include <iostream>
#include <coroutine>
#include <vector>
#include <memory>

// 1. ゲーム用コルーチンタスク（所有権管理と再開インターフェース）
class GameTask {
public:
    struct promise_type {
        GameTask get_return_object() {
            return GameTask{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() noexcept { return {}; } // 生成時は待機
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() noexcept {}
        void unhandled_exception() { std::terminate(); }
    };

    using Handle = std::coroutine_handle<promise_type>;

    explicit GameTask(Handle h) : handle_(h) {}
    ~GameTask() {
        if (handle_) handle_.destroy();
    }

    GameTask(GameTask&& other) noexcept : handle_(other.handle_) {
        other.handle_ = nullptr;
    }
    GameTask& operator=(GameTask&& other) noexcept {
        if (this != &other) {
            if (handle_) handle_.destroy();
            handle_ = other.handle_;
            other.handle_ = nullptr;
        }
        return *this;
    }

    bool isDone() const { return !handle_ || handle_.done(); }
    void resume() {
        if (handle_ && !handle_.done()) {
            handle_.resume();
        }
    }

private:
    Handle handle_;
};

// 2. 指定秒数だけ中断する Awaiter
struct WaitForSeconds {
    float duration;
    float elapsed = 0.0f;

    explicit WaitForSeconds(float sec) : duration(sec) {}

    // await_ready: true を返すと中断せずに即座に実行を継続する
    bool await_ready() const noexcept { return duration <= 0.0f; }

    // await_suspend: 中断される直前に呼ばれる（コルーチンハンドルの保持などを行う）
    void await_suspend(std::coroutine_handle<> h) noexcept {
        // ここでタイマーマネージャ等にハンドルを登録できる
    }

    // await_resume: 再開された瞬間に呼ばれ、co_await 式の評価値を返す
    void await_resume() const noexcept {}
};

// 実戦コルーチン：ボス行動パターン
GameTask bossRoutine() {
    std::cout << "  [ボスAI] 画面上部からゆっくり下降中...\n";
    co_await WaitForSeconds(1.0f);

    std::cout << "  [ボスAI] 自機を照準ロックオン！\n";
    co_await WaitForSeconds(1.0f);

    std::cout << "  [ボスAI] ホーミングミサイル一斉発射！\n";
}

int main() {
    std::cout << "=== ゲームタスク実行マネージャー ===\n";
    GameTask boss = bossRoutine();

    int frame = 0;
    while (!boss.isDone()) {
        std::cout << "Frame " << ++frame << ": ゲームループ更新中\n";
        boss.resume();
    }
    std::cout << "=== ボス行動シーケンス完了 ===\n";
    return 0;
}

#include <iostream>
#include <coroutine>
#include <cmath>

struct Vec2 {
    float x, y;
};

// 単一の値を次々と産み出す Generator 型
template <typename T>
class Generator {
public:
    struct promise_type {
        T current_value;

        Generator get_return_object() {
            return Generator{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }

        // co_yield value; が呼ばれたときの処理
        std::suspend_always yield_value(T value) noexcept {
            current_value = value;
            return {}; // 値をセットして一時中断！
        }

        void return_void() noexcept {}
        void unhandled_exception() { std::terminate(); }
    };

    using Handle = std::coroutine_handle<promise_type>;

    explicit Generator(Handle h) : handle_(h) {}
    ~Generator() { if (handle_) handle_.destroy(); }

    // 次の値を取り出す（コルーチンを再開）
    bool next() {
        if (handle_ && !handle_.done()) {
            handle_.resume();
            return !handle_.done();
        }
        return false;
    }

    T getValue() const {
        return handle_.promise().current_value;
    }

private:
    Handle handle_;
};

// 螺旋弾幕の射出ベクトルを生成するジェネレータ
Generator<Vec2> makeSpiralBarrage(int bulletCount, float baseAngle) {
    const float PI = 3.14159265f;
    for (int i = 0; i < bulletCount; ++i) {
        float angle = baseAngle + (i * (2.0f * PI / bulletCount));
        Vec2 dir = { std::cos(angle), std::sin(angle) };
        
        // 1発分の方向ベクトルを呼び出し側に渡して一時停止！
        co_yield dir;
    }
}

int main() {
    std::cout << "--- 螺旋弾幕生成開始 (8発オンデマンド生成) ---\n";
    auto barrage = makeSpiralBarrage(8, 0.0f);

    int count = 0;
    while (barrage.next()) {
        Vec2 dir = barrage.getValue();
        std::cout << "弾 #" << ++count << " 発射ベクトル: (" 
                  << dir.x << ", " << dir.y << ")\n";
        
        // もし途中でプレイヤーがボムを使ったら、即座にループを抜けて終了可能！
        if (count >= 4) {
            std::cout << "ボム発動！残りの弾丸計算はキャンセルされました（ゼロオーバーヘッド）\n";
            break;
        }
    }
    return 0;
}

#include <iostream>
#include <vector>
#include <coroutine>

struct CoroutineTask {
    struct promise_type {
        CoroutineTask get_return_object() {
            return CoroutineTask{std::coroutine_handle<promise_type>::from_promise(*this)};
        }
        std::suspend_always initial_suspend() noexcept { return {}; }
        std::suspend_always final_suspend() noexcept { return {}; }
        void return_void() noexcept {}
        void unhandled_exception() { std::terminate(); }
    };
    std::coroutine_handle<promise_type> h;
    bool tick() {
        if (h && !h.done()) { h.resume(); return !h.done(); }
        return false;
    }
    ~CoroutineTask() { if (h) h.destroy(); }
};

struct YieldFrame {
    bool await_ready() const noexcept { return false; }
    void await_suspend(std::coroutine_handle<>) const noexcept {}
    void await_resume() const noexcept {}
};

// 1フレーム待機するヘルパー関数
auto waitFrames(int frames) -> CoroutineTask {
    for (int i = 0; i < frames; ++i) {
        co_await YieldFrame{};
    }
}

// ボス行動AI：完全な直線コードで時間差攻撃を記述
CoroutineTask bossAI() {
    std::cout << "[Boss] フェーズ1：左右への威嚇移動開始\n";
    for (int f = 0; f < 3; ++f) {
        std::cout << "  ボス位置移動...\n";
        co_await YieldFrame{};
    }

    std::cout << "[Boss] フェーズ2：中央へテレポート！警告発令！\n";
    co_await YieldFrame{};

    std::cout << "[Boss] フェーズ3：3WAY全方位弾幕一斉射撃！\n";
    co_await YieldFrame{};

    std::cout << "[Boss] 行動シーケンス完了。ループ待機へ\n";
}

int main() {
    std::cout << "=== インベーダー・ボス コルーチンAI稼働 ===\n";
    CoroutineTask boss = bossAI();

    int frameCount = 0;
    while (boss.tick()) {
        std::cout << "--- フレーム " << ++frameCount << " 描画・物理演算同期完了 ---\n";
    }
    std::cout << "=== ボス行動終了 ===\n";
    return 0;
}

• 落とし穴1：コルーチン引数の「参照渡し（&）」によるダングリング参照: コルーチンに参照（const std::string& など）を渡すと、呼び出し元のローカル変数がスコープを抜けて消滅した後にコルーチンが再開され、未定義動作やクラッシュを引き起こします。コルーチンの引数は必ず「値渡し（Value copy）」またはスマートポインタで渡すのが鉄則です。
• 落とし穴2：コルーチンハンドルの二重破棄・解放漏れ: std::coroutine_handle は生ポインタと同等です。RAII クラス（Task クラスのデストラクタで handle.destroy() を呼ぶ）を作成し、必ず所有権を一元管理してください。
• 落とし穴3：final_suspend で suspend_never を返したときの未定義動作: final_suspend で suspend_never を返すと、コルーチン終了時にフレームが自動消滅します。その後に外側から handle.done() や handle.destroy() を呼ぶと解放済みメモリへのアクセス（Use-After-Free）になります。外側でハンドルを管理する場合は必ず suspend_always を返します。

• 1. co_await
• 2. std::yield
• 3. goto_pause
• 4. suspend_now

• 1. コンパイラが参照渡しを禁止する構文エラーを出すから
• 2. co_await で中断している間に呼び出し元の実体がスコープを抜けて破棄され、再開時にダングリング参照（未定義動作）になるから
• 3. 参照渡しを使うと自動的にマルチスレッド実行になってデッドロックするから
• 4. 参照渡しを使うとコルーチンの vtable が肥大化するから

• 1. promise_type、std::coroutine_handle、Awaiter
• 2. std::thread、std::mutex、std::condition_variable
• 3. unique_ptr、shared_ptr、weak_ptr
• 4. vector、list、unordered_map