レガシー第12章：レガシーゲームエンジン統合アーキテクチャ

#include <iostream>
#include <chrono>
#include <thread>
#include <algorithm>

class FixedTimestepEngine {
private:
    static constexpr double FIXED_DT = 1.0 / 60.0; // 60Hz固定物理ステップ (約0.01666秒)
    static constexpr double MAX_FRAME_TIME = 0.25;  // 1フレームの最大許容時間（250ms）
    
    double simulatedTime_ = 0.0;
    int physicsTickCount_ = 0;
    int renderFrameCount_ = 0;

public:
    // 物理・ロジック更新（常に一定の固定刻みで呼ばれる）
    void updatePhysics(double dt) {
        simulatedTime_ += dt;
        physicsTickCount_++;
        // ここで厳密な衝突判定、弾移動、AI思考を行う
    }

    // 描画処理（ディスプレイの描画タイミングに合わせて呼ばれる）
    // alpha は [0.0, 1.0) の範囲：前フレームと現フレームの間の補間係数
    void render(double alpha) {
        renderFrameCount_++;
        (void)alpha; // 補間描画に使用
    }

    // 1フレーム分の時間進行を処理するコア関数
    void advanceTime(double frameTime, double& accumulator) {
        // ⚠️ スパイラル・オブ・デス（Spiral of Death）防止ガード！
        // 処理落ち時に物理更新が無限増殖して完全フリーズするのを防ぐ
        if (frameTime > MAX_FRAME_TIME) {
            frameTime = MAX_FRAME_TIME;
        }

        accumulator += frameTime;

        // 蓄積された時間が固定刻み FIXED_DT 以上ある限り、何回でも物理更新を回す！
        while (accumulator >= FIXED_DT) {
            updatePhysics(FIXED_DT);
            accumulator -= FIXED_DT;
        }

        // 残余時間を物理刻みで正規化（0.0 〜 0.999...）して描画補間へ渡す
        double alpha = accumulator / FIXED_DT;
        render(alpha);
    }

    void printStats() const {
        std::cout << "[Engine Stats] 物理Tick回数: " << physicsTickCount_
                  << ", 描画Frame回数: " << renderFrameCount_
                  << ", 物理シミュレーション時間: " << simulatedTime_ << "s\n";
    }
};

int main() {
    FixedTimestepEngine engine;
    double accumulator = 0.0;

    std::cout << "--- 1. 通常フレーム (16.6ms 経過 / 60FPS) ---\n";
    for (int i = 0; i < 3; ++i) {
        engine.advanceTime(1.0 / 60.0, accumulator);
    }
    engine.printStats();

    std::cout << "\n--- 2. 激しい処理落ち発生！ (1フレームで 100ms 経過) ---\n";
    // 100ms = 0.1秒 -> 約6回分の物理更新が一気に追いつき処理される！
    engine.advanceTime(0.100, accumulator);
    engine.printStats();

    return 0;
}

#include <iostream>
#include <vector>
#include <memory>
#include <string>

// サブシステムの標準インターフェース
class IEngineSubsystem {
public:
    virtual ~IEngineSubsystem() = default;
    virtual const char* getName() const = 0;
    virtual bool startup() = 0;
    virtual void update(double dt) = 0;
    virtual void shutdown() = 0;
};

// 1. 入力サブシステム
class InputSubsystem : public IEngineSubsystem {
public:
    const char* getName() const override { return "InputSubsystem"; }
    bool startup() override {
        std::cout << "  [OK] InputSubsystem 起動 (キーボード/マウス初期化)\n";
        return true;
    }
    void update(double dt) override { (void)dt; }
    void shutdown() override {
        std::cout << "  [SHUTDOWN] InputSubsystem 終了\n";
    }
};

// 2. サウンドサブシステム
class AudioSubsystem : public IEngineSubsystem {
public:
    const char* getName() const override { return "AudioSubsystem"; }
    bool startup() override {
        std::cout << "  [OK] AudioSubsystem 起動 (オーディオデバイス・バッファ確保)\n";
        return true;
    }
    void update(double dt) override { (void)dt; }
    void shutdown() override {
        std::cout << "  [SHUTDOWN] AudioSubsystem 終了 (再生停止・ドライバ解放)\n";
    }
};

// 3. レンダリングサブシステム
class RenderSubsystem : public IEngineSubsystem {
public:
    const char* getName() const override { return "RenderSubsystem"; }
    bool startup() override {
        std::cout << "  [OK] RenderSubsystem 起動 (GPUコンテキスト・スワップチェーン生成)\n";
        return true;
    }
    void update(double dt) override { (void)dt; }
    void shutdown() override {
        std::cout << "  [SHUTDOWN] RenderSubsystem 終了 (GPUリソース解放・ウィンドウ破棄)\n";
    }
};

// エンジンカーネル：サブシステムのオーケストレーションを担当
class EngineKernel {
private:
    std::vector<std::unique_ptr<IEngineSubsystem>> subsystems_;
    bool isRunning_ = false;

public:
    template <typename T, typename... Args>
    void registerSubsystem(Args&&... args) {
        subsystems_.push_back(std::make_unique<T>(std::forward<Args>(args)...));
    }

    bool startup() {
        std::cout << "=== エンジン起動シークエンス開始 ===\n";
        for (auto& sys : subsystems_) {
            if (!sys->startup()) {
                std::cerr << "致命的エラー: " << sys->getName() << " の起動に失敗！\n";
                shutdown();
                return false;
            }
        }
        isRunning_ = true;
        std::cout << "=== 全サブシステム起動完了 (ゲーム稼働可能) ===\n\n";
        return true;
    }

    void update(double dt) {
        if (!isRunning_) return;
        for (auto& sys : subsystems_) {
            sys->update(dt);
        }
    }

    // 終了時は登録の「完全な逆順（LIFO）」で解放する！
    void shutdown() {
        std::cout << "\n=== エンジン終了シークエンス開始 (逆順シャットダウン) ===\n";
        for (auto it = subsystems_.rbegin(); it != subsystems_.rend(); ++it) {
            (*it)->shutdown();
        }
        subsystems_.clear();
        isRunning_ = false;
        std::cout << "=== 全サブシステム安全破棄完了 ===\n";
    }

    ~EngineKernel() {
        if (isRunning_) {
            shutdown();
        }
    }
};

int main() {
    EngineKernel engine;

    // 依存関係に従って登録順を決定（Input -> Audio -> Render）
    engine.registerSubsystem<InputSubsystem>();
    engine.registerSubsystem<AudioSubsystem>();
    engine.registerSubsystem<RenderSubsystem>();

    if (engine.startup()) {
        engine.update(1.0 / 60.0);
    }

    // 終了時は自動的に Render -> Audio -> Input の逆順で安全終了される！
    return 0;
}

#include <iostream>
#include <memory>
#include <string>

// 描画抽象インターフェース
class IRenderer {
public:
    virtual ~IRenderer() = default;
    virtual void clearScreen() = 0;
    virtual void drawSprite(int id, float x, float y) = 0;
    virtual void present() = 0;
};

// 1. 本番用：コンソール/グラフィックス描画
class ConsoleRenderer : public IRenderer {
public:
    void clearScreen() override { /* 画面消去 */ }
    void drawSprite(int id, float x, float y) override {
        std::cout << "[Draw] スプライトID=" << id << " を (" << x << ", " << y << ") に描画\n";
    }
    void present() override {
        std::cout << "[Screen] 画面バッファをフリップ表示\n";
    }
};

// 2. CI/テスト用：ヘッドレス・ヌルレンダラ（画面出力ゼロ・超高速）
class NullRenderer : public IRenderer {
public:
    void clearScreen() override {}
    void drawSprite(int id, float x, float y) override { (void)id; (void)x; (void)y; }
    void present() override {}
};

// ゲームワールド：レンダラに直接依存せず、抽象インターフェースに依存
class GameWorld {
private:
    IRenderer& renderer_;
    float playerX_ = 100.0f;
    float playerY_ = 200.0f;

public:
    GameWorld(IRenderer& renderer) : renderer_(renderer) {}

    void render() {
        renderer_.clearScreen();
        renderer_.drawSprite(1, playerX_, playerY_); // 自機
        renderer_.present();
    }

    void movePlayer(float dx, float dy) {
        playerX_ += dx;
        playerY_ += dy;
    }

    float getPlayerX() const { return playerX_; }
};

int main() {
    std::cout << "--- A. 本番グラフィックス実行 ---\n";
    ConsoleRenderer realRenderer;
    GameWorld game(realRenderer);
    game.render();

    std::cout << "\n--- B. CIサーバー用ヘッドレス自動テスト (画面なし・超高速) ---\n";
    NullRenderer nullRenderer;
    GameWorld testWorld(nullRenderer);
    // 画面を出さずに1000回移動ロジックを回してアサーション検証！
    for (int i = 0; i < 1000; ++i) {
        testWorld.movePlayer(1.0f, 0.0f);
    }
    std::cout << "テスト完了: 最終自機X座標 = " << testWorld.getPlayerX() << " (期待値: 1100)\n";

    return 0;
}

// Shirokuma 2D Game Engine Core Loop
class ShirokumaGameEngine {
public:
    void run() {
        kernel_.startup();
        
        while (isRunning_) {
            // 1. OSイベント・入力ポーリング
            input_.pollEvents();
            if (input_.isQuitRequested()) break;

            // 2. 固定デルタタイムによる決定論的物理・ロジック更新
            double frameTime = timer_.getElapsedSeconds();
            accumulator_ += std::min(frameTime, MAX_FRAME_TIME);

            while (accumulator_ >= FIXED_DT) {
                world_.update(FIXED_DT);
                audio_.update(FIXED_DT);
                accumulator_ -= FIXED_DT;
            }

            // 3. 残余時間 alpha による滑らかな補間描画
            double alpha = accumulator_ / FIXED_DT;
            renderer_.beginFrame();
            world_.render(renderer_, alpha);
            renderer_.endFrame();
        }

        kernel_.shutdown(); // 登録の完全逆順で安全破棄！
    }
};

• 落とし穴1：スパイラル・オブ・デス（処理落ちの死の連鎖）: 1フレームの処理が重くて0.5秒かかった場合、次のフレームで0.5秒分（約30回分）の物理演算を一気に回そうとしてさらに処理落ちしゲームが凍結します。必ず frameTime = std::min(frameTime, 0.25); のように最大上限クランプを設けます。
• 落とし穴2：サブシステム同士の相互参照（循環依存）: AudioSubsystem と RenderSubsystem が直接互いを参照すると初期化順序が破綻します。Observer パターンやイベントバスを介して疎結合に通信します。
• 落とし穴3：サブシステムのシングルトン乱用: どこからでも呼べるグローバル Singleton を乱用すると、並行テストやDIが不可能になります。サブシステムは EngineKernel が一括所有し参照を渡すのがクリーンです。

• 1. C++コンパイラがインライン展開できなくなるため、コンパイル時間が長くなる
• 2. フレーム落ちした瞬間に dt が巨大化し、弾が壁や敵の当たり判定を飛び越える「トンネリング現象」が起きる
• 3. CPUのL1キャッシュがフラグメンテーションを起こしてハードウェアが停止する
• 4. 仮想関数テーブル（vtable）のサイズがフレームごとに動的拡張されてしまう

• 1. 名前のアルファベット昇順（AからZの順）で終了させる
• 2. ランダムな順序で終了させ、残ったメモリはOSの自動回収に任せる
• 3. 初期化（Startup）した順序の「完全な逆順（LIFO：スタック順）」で終了させる
• 4. すべてのサブシステムを同時に並列スレッドで一斉に破棄する

• 1. C++コードが自動的にアセンブリ言語に変換されてFPSが100倍になる
• 2. GPUやディスプレイの存在しないCIサーバーやLinuxテスト環境でも、ゲームロジックの単体テストを超高速に自動実行できる
• 3. すべての変数がコンパイル時に constexpr 評価されてバイナリサイズが半分になる
• 4. マルチスレッドにおけるデッドロックが物理的に一切発生しなくなる