【C++】第二回 C++を使ったゲーム開発 〜SDLを使った2Dゲーム開発編〜

src
├── Actors
│   ├── Actor.cpp
│   ├── Actor.h
│   ├── BombEffect.cpp
│   ├── BombEffect.h
│   ├── Enemy.cpp
│   ├── Enemy.h
│   ├── Missile.cpp
│   ├── Missile.h
│   ├── Ship.cpp
│   └── Ship.h
├── Commons
│   ├── Math.h
│   ├── Vector2.cpp
│   └── Vector2.h
├── Components
│   ├── ColliderComponent.cpp
│   ├── ColliderComponent.h
│   ├── Component.cpp
│   ├── Component.h
│   ├── ScrollSpriteComponent.cpp
│   ├── ScrollSpriteComponent.h
│   ├── SpriteComponent.cpp
│   └── SpriteComponent.h
├── Scenes
│   ├── EndScene.cpp
│   ├── EndScene.h
│   ├── GameScene.cpp
│   ├── GameScene.h
│   ├── ReadyScene.cpp
│   ├── ReadyScene.h
│   ├── Scene.cpp
│   └── Scene.h
├── Game.cpp
├── Game.h
└── main.cpp

#include "Actor.h"
#include <vector>
#include "../Game.h"
#include "../Components/Component.h"

Actor::Actor(Game* game)
:mState(EActive)
,mPosition(Vector2::Zero)
,mScale(1.0f)
,mRotation(0.0f)
,mGame(game)
{
    // アクタ追加
    mGame->AddActor(this);
}

Actor::~Actor()
{
    // アクタ削除
    mGame->RemoveActor(this);
    // コンポーネント削除
    while (!mComponents.empty())
    {
        delete mComponents.back();
    }
}

// 更新処理
void Actor::Update(float deltaTime)
{
    if (mState == EActive)
    {
        UpdateComponents(deltaTime);
        UpdateActor(deltaTime);
    }
}

// コンポーネント更新処理
void Actor::UpdateComponents(float deltaTime)
{
    for (auto component : mComponents)
    {
        component->Update(deltaTime);
    }
}

// 各アクタはoverrideして記述する
void Actor::UpdateActor(float deltaTime)
{
}

// コンポーネント追加
void Actor::AddComponent(Component* component)
{
    // 設定された更新順となるようソートする
    int myOrder = component->GetUpdateOrder();
    auto iter = mComponents.begin();
    for (; iter != mComponents.end(); ++iter)
    {
        if (myOrder < (*iter)->GetUpdateOrder())
        {
            break;
        }
    }
    mComponents.insert(iter, component);
}

// コンポーネント削除
void Actor::RemoveComponent(Component* component)
{
    auto iter = std::find(mComponents.begin(), mComponents.end(), component);
    if (iter != mComponents.end())
    {
        mComponents.erase(iter);
    }
}

#include "Component.h"
#include "../Actors/Actor.h"

Component::Component(Actor* actor, int updateOrder)
:mActor(actor)
,mUpdateOrder(updateOrder)
{
    // アクタにコンポーネントを追加
    mActor->AddComponent(this);
}

Component::~Component()
{
    // アクタからコンポーネントを削除
    mActor->RemoveComponent(this);
}

// 各コンポーネントはoverrideして記述する
void Component::Update(float deltaTime)
{
}

#include "Game.h"

// メインクラス
// *ここから処理が呼ばれる
int main(int argc, char* argv[]) {
    // 初期化->ループ->終了
    Game game;
    bool success = game.Initialize();
    if (success)
    {
        game.RunLoop();
    }
    game.Shutdown();
    return 0;
}

#include "Game.h"
#include "SDL_image.h"
#include "Actors/Actor.h"
#include "Actors/Ship.h"
#include "Actors/Enemy.h"
#include "Components/SpriteComponent.h"
#include "Components/ScrollSpriteComponent.h"
#include "Commons/Math.h"

Game::Game()
:mWindow(nullptr)
,mRenderer(nullptr)
,mTicksCount(0)
,mIsRunning(true)
,mUpdatingActors(false)
,mGameClear(false)
{
}

// ゲーム初期化
bool Game::Initialize()
{
    // SDL関連初期化
    if (!InitSDL())
    {
        SDL_Log("%s", SDL_GetError());
        return false;
    }
    // ゲーム時間取得
    mTicksCount = SDL_GetTicks();

    // シーン初期化
    InitScene();

    return true;
}

・・・略・・・

// ゲームループ処理
void Game::RunLoop()
{
    // 開始シーンを設定
    mScene = new ReadyScene(this);
    mNextScene = mScene;
    StartScene();

    while (mIsRunning)
    {
        // シーン更新処理
        UpdateScene();
        // シーン開始処理
        if (mScene->GetSceneName().compare(mNextScene->GetSceneName()) != 0)
        {
            delete mScene;
            mScene = mNextScene;
            StartScene();
        }
    }
}

・・・略・・・
// シーン開始処理
void Game::StartScene()
{
・・・略・・・
}

// シーン更新処理
void Game::UpdateScene()
{
    // 入力検知
    ProcessInput();

・・・略・・・

    // 出力処理
    GenerateOutput();
}

// ゲームループ 入力検知
void Game::ProcessInput()
{
・・・略・・・
}

// ゲームループ 出力処理
void Game::GenerateOutput()
{
・・・略・・・
}

// シャットダウン処理
void Game::Shutdown()
{
・・・略・・・
}

// ゲーム初期化
bool Game::Initialize()
{
    // SDL関連初期化
    if (!InitSDL())
    {
        SDL_Log("%s", SDL_GetError());
        return false;
    }
    // ゲーム時間取得
    mTicksCount = SDL_GetTicks();

    // シーン初期化
    InitScene();

    return true;
}

// SDL関連初期化
bool Game::InitSDL()
{
    // 初期化に失敗したらfalseを返す
    bool success = SDL_Init(SDL_INIT_VIDEO|SDL_INIT_AUDIO) == 0;
    if (!success) return false;

    mWindow = SDL_CreateWindow("ShootingGame", 100, 100, ScreenWidth, ScreenHeight, 0);
    if (!mWindow) return false;

    mRenderer = SDL_CreateRenderer(mWindow, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if (!mRenderer) return false;

    success = IMG_Init(IMG_INIT_PNG) != 0;
    if (!success) return false;

    return true;
}

// シーン初期化処理（一度だけ呼ばれる）
void Game::InitScene()
{
    // 背景の作成
    // ２枚のスクロール速度を変えて視差スクロールにする
    auto* bgBack = new Actor(this);
    bgBack->SetPosition(Vector2(ScreenWidth / 2, ScreenHeight / 2));
    auto* bgBackSprite = new ScrollSpriteComponent(bgBack, 10);
    bgBackSprite->SetTexture(LoadTexture(GetAssetsPath() + "bg_back.png"));
    bgBackSprite->SetScrollSpeedY(100.0f); // 速度：100

    auto* bgFront = new Actor(this);
    bgFront->SetPosition(Vector2(ScreenWidth / 2, ScreenHeight / 2));
    auto* bgFrontSprite = new ScrollSpriteComponent(bgFront, 20);
    bgFrontSprite->SetTexture(LoadTexture(GetAssetsPath() + "bg_front.png"));
    bgFrontSprite->SetScrollSpeedY(200.0f); // 速度：200
}

// ファイル名からテクスチャをロードする
SDL_Texture* Game::LoadTexture(const std::string& fileName)
{
    SDL_Texture* tex = nullptr;
    auto iter = mCachedTextures.find(fileName);
    if (iter != mCachedTextures.end())
    {
        // キャッシュ済なら変数から取得
        tex = iter->second;
    }
    else
    {
        // テクスチャをロードする
        SDL_Surface* surf = IMG_Load(fileName.c_str());
        if (!surf)
        {
            SDL_Log("Error load texture file %s", fileName.c_str());
            return nullptr;
        }
        tex = SDL_CreateTextureFromSurface(mRenderer, surf);
        SDL_FreeSurface(surf);
        if (!tex)
        {
            SDL_Log("Error convert surface to texture %s", fileName.c_str());
            return nullptr;
        }
        // 変数にキャッシュする
        mCachedTextures.emplace(fileName.c_str(), tex);
    }
    return tex;
}

// シャットダウン処理
void Game::Shutdown()
{
    // インスタンスを破棄
    while (!mActors.empty())
    {
        delete mActors.back();
    }
    for (auto i : mCachedTextures)
    {
        SDL_DestroyTexture(i.second);
    }
    mCachedTextures.clear();
    // SDL関連の変数を破棄
    SDL_DestroyRenderer(mRenderer);
    SDL_DestroyWindow(mWindow);
    SDL_Quit();
    IMG_Quit();
}

// ゲームループ処理
void Game::RunLoop()
{
    // 開始シーンを設定
    mScene = new ReadyScene(this);
    mNextScene = mScene;
    StartScene();

    while (mIsRunning)
    {
        // シーン更新処理
        UpdateScene();
        // シーン開始処理
        if (mScene->GetSceneName().compare(mNextScene->GetSceneName()) != 0)
        {
            delete mScene;
            mScene = mNextScene;
            StartScene();
        }
    }
}

#pragma once
#include "SDL_image.h"
#include "string"

// シーン基底クラス
// *各シーンはこのクラスを継承する
class Scene
{
public:
    Scene(class Game* game);
    virtual ~Scene();
    virtual void Start();
    virtual void Update(float deltaTime);
    virtual void ProcessInput(const Uint8* state);
    virtual std::string const GetSceneName();

protected:
    class Game* mGame;

};

#pragma once
#include "Scene.h"

// ゲームシーンクラス
class GameScene : public Scene {
public:
    GameScene(class Game* game);
    ~GameScene();
    void Start() override;
    void Update(float deltaTime) override;
    void ProcessInput(const Uint8* state) override;
    std::string const GetSceneName() override;

};

// シーン開始処理
void Game::StartScene()
{
    mScene->Start();
}

// シーン更新処理
void Game::UpdateScene()
{
    // 入力検知
    ProcessInput();

    // 最低16msは待機
    while (!SDL_TICKS_PASSED(SDL_GetTicks(), mTicksCount + 16));
    // フレームの経過時間を取得(最大50ms)
    float deltaTime = (SDL_GetTicks() - mTicksCount) / 1000.0f;
    if (deltaTime > 0.05f)
    {
        deltaTime = 0.05f;
    }
    mTicksCount = SDL_GetTicks();

    // アクタ更新処理
    mUpdatingActors = true;
    for (auto actor : mActors)
    {
        actor->Update(deltaTime);
    }
    mUpdatingActors = false;

    // 待機中のアクタを追加
    for (auto pending : mPendingActors)
    {
        mActors.emplace_back(pending);
    }
    mPendingActors.clear();

    // 各シーンの更新処理
    mScene->Update(deltaTime);

    // 死亡したアクタを破棄
    std::vector<Actor*> deadActors;
    for (auto actor : mActors)
    {
        if (actor->GetState() == Actor::EDead)
        {
            deadActors.emplace_back(actor);
        }
    }
    for (auto actor : deadActors)
    {
        delete actor;
    }

    // 出力処理
    GenerateOutput();
}

void Enemy::UpdateActor(float deltaTime)
{
    // 親のメソッド呼び出し
    Actor::UpdateActor(deltaTime);

    // 待機時間分は待つ
    mTimeCount++;
    if (mTimeCount < mWaitTime)
    {
        return;
    }

    // 移動処理
    Vector2 pos = GetPosition();
    switch (mEnemyMoveType)
    {
        case STRAIGHT:
            pos.y += mEnemySpeed * deltaTime;
            break;
        case SHAKE:
            pos.x = mInitPosition->x + (sinf(mTimeCount / 10.0f) * mEnemyShakeWidth);
            pos.y += mEnemySpeed * deltaTime;
            break;
        default:
            break;
    }
    // 画面外に出たらゲームオーバー
    if (pos.y >= Game::ScreenHeight)
    {
        SetState(EDead);
        GetGame()->SetNextScene(Game::END_SCENE);
    }
    SetPosition(pos);
}

// ゲームループ 入力検知
void Game::ProcessInput()
{
    // SDLイベント
    SDL_Event event;
    while (SDL_PollEvent(&event))
    {
        switch (event.type)
        {
            case SDL_QUIT: // ウィンドウが閉じられた時
            mIsRunning = false;
            break;
        }
    }
    // キー入力イベント
    const Uint8* state = SDL_GetKeyboardState(NULL);
    if (state[SDL_SCANCODE_ESCAPE])
    {
        mIsRunning = false;
    }

    // 各シーンの入力検知
    mScene->ProcessInput(state);
}

// キーボード入力
void Ship::ProcessKeyboard(const uint8_t* state)
{
    mRightMove = 0.0f;
    mDownMove = 0.0f;
    // キー入力で上下左右に移動させる
    if (state[SDL_SCANCODE_D])
    {
        mRightMove += ShipSpeed;
    }
    if (state[SDL_SCANCODE_A])
    {
        mRightMove -= ShipSpeed;
    }
    if (state[SDL_SCANCODE_S])
    {
        mDownMove += ShipSpeed;
    }
    if (state[SDL_SCANCODE_W])
    {
        mDownMove -= ShipSpeed;
    }
    // ミサイルを撃つ
    if (state[SDL_SCANCODE_K])
    {
        if (mIsCanShot)
        {
            // 撃つ間隔を開けるためフラグを変更
            mIsCanShot = false;
            mDeltaShotTime = 0.0f;
            // ミサイル生成
            auto* missile = new Missile(GetGame());
            Vector2 pos = GetPosition();
            missile->SetPosition(Vector2(pos.x, pos.y - 30.0f));
        }
    }
}

// ゲームループ 出力処理
void Game::GenerateOutput()
{
    // 背景色をクリア
    SDL_SetRenderDrawColor(mRenderer,19,56,111,255); // 紺色
    SDL_RenderClear(mRenderer);

    // スプライトを描画
    for (auto sprite : mSprites)
    {
        sprite->Draw(mRenderer);
    }

    // バックバッファとスワップ(ダブルバッファ)
    SDL_RenderPresent(mRenderer);
}

void SpriteComponent::Draw(SDL_Renderer* renderer)
{
    if (mTexture)
    {
        SDL_Rect r;
        // 大きさ、位置（左上座標）を設定
        r.w = static_cast<int>(mTexWidth * mActor->GetScale());
        r.h = static_cast<int>(mTexHeight * mActor->GetScale());
        r.x = static_cast<int>(mActor->GetPosition().x - r.w / 2);
        r.y = static_cast<int>(mActor->GetPosition().y - r.h / 2);
        // 描画
        SDL_RenderCopyEx(renderer,
                mTexture,
                nullptr,
                &r,
                -Math::ToDegrees(mActor->GetRotation()),
                nullptr,
                SDL_FLIP_NONE);
    }
}

// 衝突処理
bool Intersect(const ColliderComponent& a, const ColliderComponent& b)
{
    // 計算負荷軽減のためsqrtせずに比較
    // 衝突した物体との距離
    Vector2 diff = a.GetCenter() - b.GetCenter();
    float distSq = diff.LengthSq();
    // 衝突円の半径の合計以下なら衝突
    float radDiff = a.GetRadius() + b.GetRadius();
    return distSq <= radDiff * radDiff;
}

// vec length(not sqrt)
float Vector2::LengthSq() const
{
    return (x*x + y*y);
}

// アクタ更新
void Ship::UpdateActor(float deltaTime)
{

・・・略・・・

    // エネミーと衝突したら死亡
    for (auto enemy : GetGame()->GetEnemies())
    {
        if (Intersect(*mCollider, *(enemy->GetCollider())))
        {
            // ゲーム終了
            GetGame()->SetNextScene(Game::END_SCENE);
            SetState(EDead);
            // 宇宙船の位置で爆発エフェクト
            auto* bomb = new BombEffect(GetGame());
            bomb->SetPosition(Vector2(GetPosition()));
            return;
        }
    }

・・・略・・・

}

#include "BombEffect.h"
#include "../Game.h"
#include "../Components/SpriteComponent.h"

BombEffect::BombEffect(class Game *game)
:Actor(game)
,mTimeCount(0.0f)
{
    // スプライト設定
    auto* sprite = new SpriteComponent(this);
    sprite->SetTexture(GetGame()->LoadTexture(GetGame()->GetAssetsPath() + "bomb.png"));
    // 最初は大きさ0にする
    SetScale(0.0f);
}

void BombEffect::UpdateActor(float deltaTime)
{
    // 親のメソッド呼び出し
    Actor::UpdateActor(deltaTime);
    // 徐々に大きくする
    float changeScale = mTimeCount / DisplayTime * 3.0f;
    if (changeScale > 1.0f)
    {
        changeScale = 1.0f;
    }
    SetScale(changeScale);
    // 表示時間を過ぎたら破棄
    mTimeCount += deltaTime;
    if (mTimeCount >= DisplayTime)
    {
        SetState(EDead);
    }
}

// エネミーをランダム作成
for (int i = 0; i < 30; i++)
{
    auto* enemy = new Enemy(this);
    enemy->SetPosition(Vector2(Math::GetRand(100.0f, ScreenWidth - 100.0f), -100.0f));
    enemy->SetEnemySpeed(Math::GetRand(300.0f, 550.0f));
    enemy->SetScale(Math::GetRand(0.5f, 1.5f));
    // 数匹ごとに揺らす
    if (i % 2 == 0)
    {
        enemy->SetEnemyMoveType(Enemy::SHAKE);
        enemy->SetEnemyShakeWidth(Math::GetRand(5.0f, 15.0f));
    }
    // 数匹ずつ動かす
    enemy->SetWaitTime(i / 3 * Math::GetRand(80.0f, 100.0f));
}

    // 移動処理
    Vector2 pos = GetPosition();
    switch (mEnemyMoveType)
    {
        case STRAIGHT:
            pos.y += mEnemySpeed * deltaTime;
            break;
        case SHAKE:
            pos.x = mInitPosition->x + (sinf(mTimeCount / 10.0f) * mEnemyShakeWidth);
            pos.y += mEnemySpeed * deltaTime;
            break;
        default:
            break;
    }

    // random
    static std::random_device seed_gen;
    static std::default_random_engine randomEngine(seed_gen());
    inline float GetRand(float min, float max)
    {
        std::uniform_real_distribution<> dist(min, max);
        return dist(Math::randomEngine);
    }