[C++]シューティングゲーム 1

シューティングではなくアクションゲームで基礎を練習するなら ↓
https://yonezawashin.github.io/yonezawashin.github.io-2020c/practice.html

数学のベクトルの基礎を練習するなら ↓
https://yonezawashin.github.io/yonezawashin.github.io-2020c/vector.html

ポリゴンと3D描画とライティングの基礎を練習するなら(3Dエディタの作成) ↓
https://yonezawashin.github.io/yonezawashin.github.io-2020c/polygon3d/index.html

複数分割画面で複数プレイヤで遊ぶ3Dのタイルボックスゲームを制作するなら ↓
https://yonezawashin.github.io/yonezawashin.github.io-2020c/tile3d/index.html

1. シューティングC++で目指すところ(意義)
2. プロジェクトの作成
3. 画像ファイルの追加
4. Imageクラスの作成
5. Gameクラスの作成
6. 自機の作成
   - Playerクラスの作成
7. 自機弾の作成
   - 循環参照・インクルードの罠
   - シングルトン型:唯一物体タイプの追加
   - 仲介マネージャーGameManagerの追加
   - 【※メモリから弾を削除】自機弾PlayerBulletの削除処理
   - 共通削除機能を【テンプレートとして定義】
   - 【実験】メモリ浪費弾の実験
   - 自機弾の角度を変えられるようにする
   - vectorとlistの性能考察
8. ベクトル構造体でX,Y,ZをVector3型でまとめて管理する
   - ベクトルの基本
   - ベクトルの計算
   
9. 敵の作成
   - 共通のベースとなるGameObjectを作成する
   - Zako0クラスの作成
   



テキスト2もこのファイル内にまとめた。

[C++]シューティングゲーム 2



このHTMLのWEBテキストはBlueGriffonという無料のソフトで書いた
https://forest.watch.impress.co.jp/library/software/bluegriffon/
githubで自分のサイトを無料公開できるので自作サイトにも挑戦しては

シューティング[C++]で目指すところ(意義)

シューティングの制作をC++で行うことで、以下を作業を通じて【体得しよう】

• C++でのクラス定義の仕方を習得
• DXライブラリの公式のサンプルはC言語(関数方式)なので、C++ベースのオブジェクト指向のプログラミングで動かせるようになる
• C++の配列やfor文の使い方を習得
• C++での画像読み込みとそのメモリのお掃除(メモリ開放)

最終的には、C++で制作したゲームの完成を目標にしましょう。

なお、C++は下手にお金出して本を買うくらいなら以下のサイトが教科書代わりになりそうです。
・https://atcoder.jp/contests/apg4b
・https://zenn.dev/reputeless/books/standard-cpp-for-competitive-programming/viewer/string
・https://ezoeryou.github.io/cpp-intro/

プロジェクトの作成

まずはDXライブラリ公式のC++のライブラリをダウンロード

ダウンロードできたらzipファイルを【C:ドライブ直下に展開】

プロジェクト作成

今回のプロジェクト名は【1】「自分の作るゲーム名」か【2】毎回C++のプロジェクトを作るのが面倒な人は今回作るプロジェクトをフォルダごと量産するとして「DXLibGameBase」(ゲームの基礎ベース、コピペで量産用プロジェクト)にしましょう。

プロジェクトが作成されたら、まず【main.cpp】作りましょう。

少なくとも一つ【～.cpp】作らないと出てこない次にやる設定↓で【出てこない項目】があります(【C/C++全般】が出てこない！)

次にプロジェクトのややこしい設定をしっかりやる

【設定】マルチバイト文字セットを使用

【設定】C/C++→全般→追加のインクルードディレクトリにDXライブラリのフォルダ位置(PATH)を追加

【設定】リンカ→全般→追加のライブラリディレクトリにDXライブラリのフォルダ位置(PATH)を追加

【設定】リンカ→システム→サブシステムをウィンドウに(コンソールのままだと黒画面の文字ベースシステムになる)

設定を反映させたらサンプルプログラムをmain.cppにコピペして動作を確認

以下の【ウィンドウを出すだけの最小限サンプル】を動かして設定を確認しましょう

main.cpp【ウィンドウを出すだけの最小限サンプル】を編集します：

#include "DxLib.h"

// 設定画面の【リンカー】→【システム】の【サブシステム】をWindows(SUBSYSTEM:WINDOWS)に設定するとWinMainからプログラムが開始する
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
  // 画面モードの設定
  SetGraphMode( 960 , 540 , 32 ) ; // 画面サイズ960×540のカラービット数32ビットで起動
  SetWindowSize(960, 540);// ウィンドウサイズ960×540(こことSetGraphModeのサイズが異なると画像がゆがむ)
  ChangeWindowMode(TRUE);//フルスクリーン表示かウィンドウ表示か
  SetMouseDispFlag(TRUE);// ここをFALSEにするとマウスカーソル非表示
  SetMainWindowText("ゲームのウィンドウ名を変えるときはここ");//この行でエラーになったら【設定】マルチバイト文字セットが間違ってるかも
  //↑ここまでの設定は↓下のDXライブラリ初期化より先にやらないとDxLib_Init()中は画面がフルスクリーンになって終わってからウィンドウサイズが変更になり見苦しい

  // ＤＸライブラリの初期化
  if (DxLib_Init() < 0)
  {
    // DXの初期化にエラーが発生したらプログラム自体を終了(returnで)
    return -1;
  }
  
  
  // この位置にウィンドウの中に画像を描く処理などを書く
  // DXライブラリ公式の色々なサンプルを試してみよう！
  // https://dxlib.xsrv.jp/dxfunc.html
  
  
  // キー入力待ちをする
  WaitKey();
  // ＤＸライブラリの後始末
  DxLib_End();
  // ソフトの終了
  return 0;
}

解像度の定義

【C++で】画面解像度を定義するクラスを作ってみましょう。ソリューションエクスプローラーのプロジェクトを右クリックし、追加＞ヘッダファイル(.h)
Screen.hという名前でヘッダファイルを生成し、そのファイルにクラスを記述します。

Screen.hを編集します：

#ifndef _SCREEN_H
#define _SCREEN_H
// ＃ifndefは「_SCREEN_H」がifもしもn(not) def(定義)されていないなら＃endifに挟まれたコードまでを有効化する(だから2度目以降は無効になる)
// 二重定義を防止するために＃から始まる【プリプロセッサ】を使っている
//　【プリプロセッサ】はビルドする段階でコード自体に【前処理】として影響を与える
// たとえば
// ・ファイルの読み込み (including) →＃includeがこれ
// ・マクロの展開（シンボルを、あらかじめ定義された規則に従って置換する）
// ・コンパイル条件によるソースコードの部分的選択→【＃ifndef　～ ＃endifに囲まれた部分】は一度(＃defineで)定義されると無効化
// ・コメントの削除 【 // 】のコメントの削除も【プリプロセス＝前段階で行われる】

// 画面解像度
class Screen
{
public: //publicはC＃と違いpublic:以下にまとめて書かれるスタイル
  static const int Width = 960; // 幅
  static const int Height = 540; // 高さ C＃と違いstaticクラスではなく個々の【すべての変数にstaticをつけて】staticなクラスとする
};// C＃と違ってクラスの定義も;セミコロンで終わる
#endif

main.cppを編集してScreen.hを読み込ませます：

#include "DxLib.h"
#include "Screen.h"
// ↑＃includeで別ファイルのヘッダファイル.hをこのコード内に読み込む

// 設定画面の【リンカー】→【システム】の【サブシステム】をWindows(SUBSYSTEM:WINDOWS)に設定するとWinMainからプログラムが開始する
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
  // 画面モードの設定
  SetGraphMode( Screen::Width, Screen::Height, 32 ) ; // 画面サイズWidth×Heightのカラービット数32ビットで起動
  SetWindowSize(Screen::Width, Screen::Height);// ウィンドウサイズWidth×Height(こことSetGraphModeのサイズが異なると画像がゆがむ)
  ChangeWindowMode(TRUE);//フルスクリーン表示かウィンドウ表示か
  SetMouseDispFlag(TRUE);// ここをFALSEにするとマウスカーソル非表示
  SetMainWindowText("ゲームのウィンドウ名を変えるときはここ");//この行でエラーになったら【設定】マルチバイト文字セットが間違ってるかも

  // ＤＸライブラリの初期化
  if (DxLib_Init() < 0)
  {
    // DXの初期化にエラーが発生したらプログラム自体を終了(returnで)
    return -1;
  }


  // (中略).....................................

  // ソフトの終了
  return 0;
}

画像ファイルの追加

次は画像ファイルをプロジェクトに追加します。フォルダは【ウィンドウズ上のエクスプローラで作成】します。








GIMPをダウンロードして画像をつくってみましょう。
https://forest.watch.impress.co.jp/library/software/gimp/

ダウンロードしたら起動して【ファイル】→【新しい画像】


キャンバスのサイズはとりあえず64×64でつくってみます(自由につくってもよいがサイズをおぼえておいて、あとで自分のプログラムで読み込むときに合わせないといけないよ)


透明のレイヤーをつくって背景が透けるようにしておく


消しゴムで消して透明にしておく


新しいレイヤをつくって、そこのレイヤに自分の画像をえがいていく





マウスで長押しして楕円選択をえらんで円形にえがくエリアをえらぶ



ぬりつぶしの色を決めて、えらんでいるエリアを円形にぬりつぶす



テキストのボタンをおして円のうちがわに自機という文字をうちこむ



画像を保存するフォルダをつくっておく



つくったフォルダにエクスポートする





自分でboss1.png、boss2.png、boss3.pngを180×180など別のサイズでつくってみたり、
webでゲーム素材、フリーなどのワードで検索して、素材をさがしてみよう(著作権や利用規約をよく読んで注意しないとお金とられて財布が空になっちゃうので注意！！)
https://pipoya.net/sozai/
https://qiita.com/TD12734/items/5dc8068732f94452efe2


えがいた画像をべつのフォルダに保存した場合は、下のアニメようにウィンドウズでImageフォルダーにコピーして貼り付けしてください。

試しに表示してみる

main.cppにプログラムを追加し、画像が正しく表示できるかテストします。

#include "DxLib.h"
#include <assert.h> // 画像読み込みの読込み失敗表示用
#include "Screen.h"
// ＃includeで別ファイルのヘッダファイル.hをこのコード内に読み込む

// 設定画面の【リンカー】→【システム】の【サブシステム】をWindows(SUBSYSTEM:WINDOWS)に設定するとWinMainからプログラムが開始する
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
  // 画面モードの設定
  SetGraphMode(Screen::Width, Screen::Height, 32 ) ; // 画面サイズWidth×Heightのカラービット数32ビットで起動
  SetWindowSize(Screen::Width, Screen::Height);// ウィンドウサイズWidth×Height(こことSetGraphModeのサイズが異なると画像がゆがむ)
  ChangeWindowMode(TRUE);//フルスクリーン表示かウィンドウ表示か
  SetMouseDispFlag(TRUE);// ここをFALSEにするとマウスカーソル非表示
  SetMainWindowText("ゲームのウィンドウ名を変えるときはここ");//この行でエラーになったら【設定】マルチバイト文字セットが間違ってるかも

  // ＤＸライブラリの初期化
  if (DxLib_Init() < 0)
  {
    // DXの初期化にエラーが発生したらプログラム自体を終了(returnで)
    return -1;
  }


  //表示しているスクリーンの後ろで隠れて次に描く画像を先に描くモード
  // これとペアでScreenFlip();でつぎのページと入れ替えでちらつきを防ぐ
  SetDrawScreen(DX_SCREEN_BACK);

  // ゲームのwhileループを開始する前の初期化処理
  int bossImage = -1;
  bossImage = LoadGraph("Image/boss1.png");
  assert(bossImage != -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる
  int x = 100; // Xの初期位置
  int vx = 10;

  ScreenFlip();

  // アニメーション(パラパラ漫画)するにはWhile文
  while (ProcessMessage() == 0)
  {// ProcessMessage() == 0になるのは×ボタン押したときなど
    ClearDrawScreen();// 一旦キャンバスをきれいにまっさらに

    // 1フレームごとの更新処理
    if (x < 0)
    {
      vx = 10; //速度の変更
    }
    else if (x > Screen::Width)
    {
      vx = -10;
    }
    x += vx; // X位置の更新

    // 描画処理(位置x, y, 拡大率, 回転, 画像ID, TRUEなら透過有効)
    DrawRotaGraphF(x, 200, 1.0f, 0, bossImage, TRUE);

    ScreenFlip(); //隠れて裏側で描いておいた画像を表面に入れ替え
  }

  // キー入力待ちをする
  WaitKey();
  // ＤＸライブラリの後始末
  DxLib_End();
  // ソフトの終了
  return 0;
}

Imageクラスの作成

Imageクラスの作成

Imageクラスを作成しましょう。Imageクラスの役割は次の2つです。

• 画像の読み込み
• 読み込んだ画像ハンドルの保持

ソリューションエクスプローラーからプロジェクトを右クリックし、追加＞ヘッダファイル
「Image」という名前でヘッダファイルを作り、クラスを定義します。

Image.hの内容を次のようにします：

#ifndef IMAGE_H_
#define IMAGE_H_

#include "DxLib.h"
#include <assert.h> // 画像読み込みの読込み失敗表示用

class Image
{
public:
  Image() {}; // 初期化コンストラクタ:定義と{}空の処理
  ~Image() {}; // 破棄する処理デストラクタ:定義と{}空の処理
  static void Load();

  static int bossImage; //ボス画像のハンドラ(読込画像番号)

private:

};
#endif

次に対となるcppファイルを作成します。
ソリューションエクスプローラーからプロジェクトを右クリックし、追加＞cppファイル
「Image.cpp」という名前でcppファイルを作り、クラスを実装します。

Image.cppの内容を次のようにします：

#include "Image.h"

int Image::bossImage{-1}; // Load終わっても-1(初期値)のままだと画像ロードが失敗してますね

void Image::Load()
{
  bossImage = LoadGraph("Image/boss1.png");
  assert(bossImage != -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる
}

試しに【Image.hを使って】表示してみる

main.cppのプログラムを変更し、画像が正しく表示できるかテストします。

#include "DxLib.h"
#include "Screen.h"
#include "Image.h" // 画像読み込みクラス


// 設定画面の【リンカー】→【システム】の【サブシステム】をWindows(SUBSYSTEM:WINDOWS)に設定するとWinMainからプログラムが開始する
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
  // 画面モードの設定
  SetGraphMode(Screen::Width, Screen::Height, 32 ) ; // 画面サイズWidth×Heightのカラービット数32ビットで起動
  SetWindowSize(Screen::Width, Screen::Height);// ウィンドウサイズWidth×Height(こことSetGraphModeのサイズが異なると画像がゆがむ)
  ChangeWindowMode(TRUE);//フルスクリーン表示かウィンドウ表示か
  SetMouseDispFlag(TRUE);// ここをFALSEにするとマウスカーソル非表示
  SetMainWindowText("ゲームのウィンドウ名を変えるときはここ");//この行でエラーになったら【設定】マルチバイト文字セットが間違ってるかも

  // ＤＸライブラリの初期化
  if (DxLib_Init() < 0)
  {
    // DXの初期化にエラーが発生したらプログラム自体を終了(returnで)
    return -1;
  }

  //表示しているスクリーンの後ろで隠れて次に描く画像を先に描くモード
  // これとペアでScreenFlip();でつぎのページと入れ替えでちらつきを防ぐ
  SetDrawScreen(DX_SCREEN_BACK);

  // ゲームのwhileループを開始する前の初期化処理
  Image::Load();
  int bossImage = -1;
  bossImage = LoadGraph("Image/boss1.png");
  assert(bossImage != -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる
  int x = 100; // Xの初期位置
  int vx = 10;

  ScreenFlip();

  // アニメーション(パラパラ漫画)するにはWhile文
  while (ProcessMessage() == 0)
  {// ProcessMessage() == 0になるのは×ボタン押したときなど
    ClearDrawScreen();// 一旦キャンバスをきれいにまっさらに

    // 1フレームごとの更新処理
    if (x < 0)
    {
      vx = 10; //速度の変更
    }
    else if (x > Screen::Width)
    {
      vx = -10;
    }
    x += vx; // X位置の更新

    // 描画処理(位置x, y, 拡大率, 回転, 画像ID, TRUEなら透過有効)
    DrawRotaGraphF(x, 200, 1.0f, 0, Image::bossImage, TRUE);

    ScreenFlip(); //隠れて裏側で描いておいた画像を表面に入れ替え
  }

  // キー入力待ちをする
  WaitKey();
  // ＤＸライブラリの後始末
  DxLib_End();
  // ソフトの終了
  return 0;
}

Gameクラスの作成

Gameクラスの作成

Gameクラスを作成しましょう。Gameクラスの重要な役割は次の3つ。

• 初期処理Init() : ゲームのwhileループが始まる前に色んな初期化処理をする
• 更新処理Update() : ゲームをプレイしている間毎フレームごとに実行される(キャラを1ずつ動かすなど)
• 描画処理Draw() : ゲームをプレイしている間毎フレームごとに実行される(キャラをアニメさせながらパラパラ漫画のように描くなど)

ソリューションエクスプローラーからプロジェクトを[右クリック]し、[追加] → [新しい項目] → Game.hというファイル名を入力
「Game.h」という名前でヘッダファイルを作り、クラスを定義します。

Game.hの内容を次のようにします：

#ifndef GAME_H_
#define GAME_H_

#include "Image.h"
#include "Screen.h"

class Game
{
public :
  /*        ↓{ }を.hに書くことでcppに分けて書くはずの処理ぶぶんを.hに書いてもよい */
  Game() {  }; // 初期化コンストラクタ
  ~Game() {  }; // 破棄処理デストラクタ
  void Init(); // Init処理(定義だけ)
  void Update(); // 更新処理(定義だけ)
  void Draw();// 描画処理(定義だけ)

  int x = 0; //staticじゃないintはここで=0で初期化できる
  int vx = 0;

};
#endif

次に対となるcppファイルを作成します。
ソリューションエクスプローラーからプロジェクトを[右クリック]し、[追加] → [新しい項目] → Game.cppというファイル名を入力
「Game.cpp」という名前でcppファイルを作り、クラスの処理を実装します。

Game.cppの内容を次のようにします：

#include "Game.h"

void Game::Init()
{// Init処理
  Image::Load(); //画像の読込み
  x = 100; // Xの初期位置
  vx = 10; // ボスの初期速度
}

void Game::Update()
{// 更新処理

  if (x < 0)
  {
    vx = 10; //速度の変更
  }
  else if (x > Screen::Width)
  {
    vx = -10; //画面端で移動方向反転
  }
  x += vx; // ボス画像のX位置の更新

}

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 1.0f, 0, Image::bossImage, TRUE);

}

【Gameクラスを使って】表示してみる

main.cppのプログラムを変更し、画像が正しくGameクラスで表示できるかテストします。

#include "DxLib.h"
#include "Screen.h"
#include "Image.h" // 画像読み込みクラス
#include "Game.h" 


// 設定画面の【リンカー】→【システム】の【サブシステム】をWindows(SUBSYSTEM:WINDOWS)に設定するとWinMainからプログラムが開始する
int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nCmdShow)
{
  // 画面モードの設定
  SetGraphMode(Screen::Width, Screen::Height, 32 ) ; // 画面サイズWidth×Heightのカラービット数32ビットで起動
  SetWindowSize(Screen::Width, Screen::Height);// ウィンドウサイズWidth×Height(こことSetGraphModeのサイズが異なると画像がゆがむ)
  ChangeWindowMode(TRUE);//フルスクリーン表示かウィンドウ表示か
  SetMouseDispFlag(TRUE);// ここをFALSEにするとマウスカーソル非表示
  SetMainWindowText("ゲームのウィンドウ名を変えるときはここ");//この行でエラーになったら【設定】マルチバイト文字セットが間違ってるかも

  // ＤＸライブラリの初期化
  if (DxLib_Init() < 0)
  {
    // DXの初期化にエラーが発生したらプログラム自体を終了(returnで)
    return -1;
  }

  //表示しているスクリーンの後ろで隠れて次に描く画像を先に描くモード
  // これとペアでScreenFlip();でつぎのページと入れ替えでちらつきを防ぐ
  SetDrawScreen(DX_SCREEN_BACK);

  // ゲームのwhileループを開始する前の初期化処理
  Image::Load();
  int x = 100; // Xの初期位置
  int vx = 10;
  // Init初期化処理
  Game game; //Gameの定義(定義と同時に初期化コンストラクタが実行される)
  game.Init(); // gameのInit準備

  ScreenFlip();

  // アニメーション(パラパラ漫画)するにはWhile文
  while (ProcessMessage() == 0)
  {// ProcessMessage() == 0になるのは×ボタン押したときなど
    ClearDrawScreen();// 一旦キャンバスをきれいにまっさらに

    // Update更新処理
    game.Update(); // gameの更新処理
    
    // Draw描画処理
    game.Draw();
    
    ScreenFlip(); //隠れて裏側で描いておいた画像を表面に入れ替え
  }

  // キー入力待ちをする
  WaitKey();
  // ＤＸライブラリの後始末
  DxLib_End();
  // ソフトの終了
  return 0;
}

自機の作成

プレイヤを操作するには便利クラスInputクラスが必須！

Inputクラスを作成しましょう。

• static int のstaticタイプの変数は.hだけではシンボリックエラーになるのでこのためだけに最低限.cppファイルを作成する必要がある

ソリューションエクスプローラーからプロジェクトを[右クリック]し、[追加] → [新しい項目] → Game.hというファイル名を入力
「Input.h」という名前でヘッダファイルを作り、クラスを定義します。

Input.hを新規作成して以下を実装

#ifndef INPUT_H_
#define INPUT_H_

#include "DxLib.h"


// 入力クラス
class Input
{
public:
  static int prevState; // 1フレーム前の状態
  static int currentState; // 現在の状態

  // 初期化。最初に1回だけ呼んでください。
  static void Init()
  {
    prevState = 0;
    currentState = 0;
  }

  // 最新の入力状況に更新する処理。
  // 毎フレームの最初に（ゲームの処理より先に）呼んでください。
  static void Update()
  {
    prevState = currentState;

    currentState =  GetJoypadInputState(DX_INPUT_KEY_PAD1);
  }

  // ボタンが押されているか？
  static bool GetButton(int buttonId)
  {
    // 今ボタンが押されているかどうかを返却
    return (currentState & buttonId) != 0;
  }

  // ボタンが押された瞬間か？
  static bool GetButtonDown(int buttonId)
  {
    // 今は押されていて、かつ1フレーム前は押されていない場合はtrueを返却
    return ((currentState & buttonId) & ~(prevState & buttonId)) != 0;
  }

  // ボタンが離された瞬間か？
  static bool GetButtonUp(int buttonId)
  {
    // 1フレーム前は押されていて、かつ今は押されていない場合はtrueを返却
    return ((prevState & buttonId) & ~(currentState & buttonId)) != 0;
  }
}; //←【注意】クラス定義の終わりにはコロンが必要だよ！

#endif  //ここでエラー出た人は↑【注意】の;コロン忘れ

次に対となるcppファイルを作成します。
ソリューションエクスプローラーからプロジェクトを[右クリック]し、[追加] → [新しい項目] → Input.cppというファイル名を入力
「Input.cpp」という名前でcppファイルを作ります(たった2行の初期化static int変数の初期化のために必須)。

Input.cppを新規作成して、その内容を次のようにします：

#include "Input.h"

int Input::prevState { 0 }; // 1フレーム前の状態
int Input::currentState { 0 }; // 現在の状態
// ↑static intのときはこの行書かないとシンボリックエラーになる件(このためだけにcpp書かなきゃならん)

Playerクラスを作成する前に、忘れずにプレイヤ画像はDXのプロジェクトのImageフォルダにコピー貼り付けしましょう。
Imageフォルダにコピーしたらプロジェクトで

次は画像ファイルをプロジェクトに追加します。画像は【プロジェクトを右クリックで「追加」→「既存の項目」で画像を追加】します。


Image.hの内容を次のようにします：

#ifndef IMAGE_H_
#define IMAGE_H_

#include "DxLib.h"
#include <assert.h> // 画像読み込みの読込み失敗表示用

class Image
{
public:
  Image() {}; // 初期化コンストラクタ:定義と{}空の処理
  ~Image() {}; // 破棄する処理デストラクタ:定義と{}空の処理
  static void Load();

  static int bossImage; //ボス画像のハンドラ(読込画像番号)
  static int player; //プレイヤ画像のハンドラ

private:

};
#endif

次に対となるcppファイルも変更します。
Image.cppの内容を次のようにします：

#include "Image.h"

int Image::bossImage{-1}; // Load終わっても-1(初期値)のままだと画像ロードが失敗してますね
int Image::player{-1};

void Image::Load()
{
  bossImage = LoadGraph("Image/boss1.png");
  assert(bossImage != -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  player= LoadGraph("Image/player.png");
  assert(player!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる
}

Playerクラスの作成

Playerクラスを作成しましょう。
Playerクラスをつくるだけで安心すると【落とし穴】があります。Game.cppでInput.Update();を忘れるとプレイヤが動きません。

Update()やDraw()やInput.Update()を忘れないように注意して進めましょう。

ソリューションエクスプローラーからプロジェクトを[右クリック]し、[追加] → [新しい項目] → Player.hというファイル名を入力
「Player.h」という名前でヘッダファイルを作り、クラスを定義します。

Player.hの内容を次のようにします：

#ifndef PLAYER_H_
#define PLAYER_H_

#include "DxLib.h"
#include "Input.h"
#include "Image.h"

class Player
{
public:
  const float MoveSpeed = 6; // 移動速度

  float x; // x座標
  float y; // y座標

  // コンストラクタ
  // x : 初期位置x
  // y : 初期位置y
  Player(float x, float y)
  {
    this->x = x;
    this->y = y;
  }

  // 更新処理
  void Update()
  {
    float vx = 0; // x方向移動速度
    float vy = 0; // y方向移動速度

    if (Input::GetButton(PAD_INPUT_LEFT))
    {
      vx = -MoveSpeed; // 左
    }
    else if (Input::GetButton(PAD_INPUT_RIGHT))
    {
      vx = MoveSpeed; // 右
    }
    if (Input::GetButton(PAD_INPUT_UP))
    {
      vy = -MoveSpeed; // 上
    }
    else if (Input::GetButton(PAD_INPUT_DOWN))
    {
      vy = MoveSpeed; // 下
    }

    // 実際に位置を動かす
    x += vx;
    y += vy;
  }

  // 描画処理
  void Draw()
  {
    DrawRotaGraphF(x, y, 1.0f, 0, Image::player, TRUE);
  }
};

#endif

Game.hにPlayerを追加します：

#ifndef GAME_H_
#define GAME_H_

#include "Image.h"
#include "Screen.h"
#include "Player.h"

class Game
{
public :
  /*        ↓{ }を.hに書くことでcppに分けて書くはずの処理ぶぶんを.hに書いてもよい */
  Game() {  }; // 初期化コンストラクタ
  ~Game() {  }; // 破棄処理デストラクタ
  void Init(); // Init処理(定義だけ)
  void Update(); // 更新処理(定義だけ)
  void Draw();// 描画処理(定義だけ)

  int x = 0; //staticじゃないintはここで=0で初期化できる
  int vx = 0;

  Player player{ 100, Screen::Height / 2 }; // 自機の初期化
};
#endif

次にGame.cppファイルにUpdateとDraw処理を追加してプレイヤの動作を確認しましょう。

Game.cppの内容を次のようにします：

#include "Game.h"

void Game::Init()
{// Init処理
  Image::Load(); //画像の読込み
  x = 100; // Xの初期位置
  vx = 10; // ボスの初期速度
}

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  if (x < 0)
  {
    vx = 10; //速度の変更
  }
  else if (x > Screen::Width)
  {
    vx = -10; //画面端で移動方向反転
  }
  x += vx; // ボス画像のX位置の更新

  player.Update(); // プレイヤの更新【忘れるとプレイヤが動かない】
}

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 1.0f, 0, Image::bossImage, TRUE);

  player.Draw(); // プレイヤの更新【忘れるとプレイヤ表示されない】
}

さて、無事にプレイヤをキー入力(↑↓←→)で動かせるようになりましたか？？？。

• 【プレイヤ画像が出ない】→Game.cppで【player.Draw();しましたか？】
• 【プレイヤ画像が動かない1】→Game.cppで【player.Update();しましたか？】
• 【プレイヤ画像が動かない2】→Game.cppで【Input.Update();しましたか？】

√2の定義

【C++でも】斜め方向の移動速度を√2で割って補正するために、自分用数学定義クラスを作ってみましょう。ソリューションエクスプローラーのプロジェクトを右クリックし、追加＞ヘッダファイル(.h)
MyMath.hという名前でヘッダファイルを生成し、そのファイルにクラスを記述します。

MyMath.hを新規作成してその内容を編集します：

#ifndef _MYMATH_H
#define _MYMATH_H
// 数学関連クラス
class MyMath
{
public:
  // C++標準では、静的static定数は【整数型】または【列挙型】のみを.hのクラス内で初期化できます。
  // これが、intやenumの初期化はエラーにならないのに他のstatic floatなどがエラーになる理由です。

  // ルート2(変数名の定義だけ)
  static const float Sqrt2; // = 1.41421356237f;(.hではfloat小数型の初期化はできない int型はできるのに)

}; // 【注意】セミコロン抜けで【宣言が必要ですエラー】

#endif // 【宣言が必要ですエラーは上のセミコロン抜け】

MyMath.cppを新規作成してその内容を編集して変数名にSqrt2 = √2 = 1.41421356237f を 割り当てます。

#include "MyMath.h"

const float MyMath::Sqrt2 = 1.41421356237f;//(floatは有効桁は実質7桁まで正確だがそれ以降は環境によって誤差出る)

定義だけじゃなく、実際にプレイヤを動かしているPlayer.hも編集しなきゃ意味がないよ！お忘れなく！！
Player.hの内容を次のようにします：

#ifndef PLAYER_H_
#define PLAYER_H_

#include "DxLib.h"
#include "Input.h"
#include "Image.h"
#include "MyMath.h"

class Player
{
public:
 const float MoveSpeed = 6; // 移動速度

 float x; // x座標
 float y; // y座標

  // コンストラクタ
  // x : 初期位置x
  // y : 初期位置y
 Player(float x, float y)
  {
    this->x = x;
    this->y = y;
  }

  // 更新処理
 void Update()
  {
    float vx = 0; // x方向移動速度
    float vy = 0; // y方向移動速度

    if (Input::GetButton(PAD_INPUT_LEFT))
    {
      vx = -MoveSpeed; // 左
    }
    else if (Input::GetButton(PAD_INPUT_RIGHT))
    {
      vx = MoveSpeed; // 右
    }
    if (Input::GetButton(PAD_INPUT_UP))
    {
      vy = -MoveSpeed; // 上
    }
    else if (Input::GetButton(PAD_INPUT_DOWN))
    {
      vy = MoveSpeed; // 下
    }

    // 斜め移動も同じ速度になるように調整
    if (vx != 0 && vy != 0)
    {
      vx /= MyMath::Sqrt2;
      vy /= MyMath::Sqrt2;
    }
    // 実際に位置を動かす
    x += vx;
    y += vy;
  }

  // 描画処理
 void Draw()
  {
    DrawRotaGraphF(x, y, 1, 0, Image::player, TRUE);
  }
};

#endif

自機弾PlayerBulletクラスの作成

PlayerBulletクラスを新規作成しましょう。

ソリューションエクスプローラーからプロジェクトを[右クリック]し、[追加] → [新しい項目] → PlayerBullet.hというファイル名を入力
「PlayerBullet.h」という名前でヘッダファイルを作り、クラスを定義します。

PlayerBullet.hの内容を次のようにします：

#ifndef PLAYERBULLET_H_
#define PLAYERBULLET_H_

#include "DxLib.h"
#include "Image.h"

// 自機弾クラス
class PlayerBullet
{
public:
  const float Speed = 25; // 移動速度

  float x; // x座標
  float y; // y座標

  // コンストラクタ
  PlayerBullet(float x, float y)
  {
    this->x = x;
    this->y = y;
  }

  // 更新処理
  void Update()
  {
    // 移動
    x += Speed;
  }

  // 描画処理
  void Draw()
  {
    DrawRotaGraphF(x, y, 1, 0, Image::playerBullet,TRUE);
  }
};


#endif

#ifndef IMAGE_H_
#define IMAGE_H_

#include "DxLib.h"
#include <assert.h> // 画像読み込みの読込み失敗表示用

class Image
{
public:
  Image() {}; // 初期化コンストラクタ:定義と{}空の処理
  ~Image() {}; // 破棄する処理デストラクタ:定義と{}空の処理
  static void Load();

  static int bossImage; //ボス画像のハンドラ(読込画像番号)
  static int player; //プレイヤ画像のハンドラ
  static int playerBullet; //プレイヤの弾画像のハンドラ

private:

};
#endif

次に対となるcppファイルも変更します。
Image.cppの内容を次のようにします：

#include "Image.h"

int Image::bossImage{-1}; // Load終わっても-1(初期値)のままだと画像ロードが失敗してますね
int Image::player{-1};
int Image::playerBullet{-1};

void Image::Load()
{
  bossImage = LoadGraph("Image/boss1.png");
  assert(bossImage != -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  player= LoadGraph("Image/player.png");
  assert(player!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  playerBullet = LoadGraph("Image/player_bullet.png");
  assert(playerBullet!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる
}

Game.hにPlayerBulletを追加します：

#ifndef GAME_H_
#define GAME_H_

#include <vector>// 配列std::vectorを使う
#include <memory>//スマートなポインタを使うのに必要(shared_ptrなど)

#include "Image.h"
#include "Screen.h"
#include "Player.h"


//前方宣言でPlayerBulletという【ポインタの型】があることだけを宣言すれば#includeせずにstd::vectorの中身にPlayerBulletのリンクだけなら入れられる
class PlayerBullet;

class Game
{
public :
  Game() {}; // 初期化コンストラクタ
  ~Game() {}; // 破棄処理デストラクタ
  void Init(); // Init処理(定義だけ)
  void Update(); // 更新処理(定義だけ)
  void Draw();// 描画処理(定義だけ)

  int x = 0;
  int vx = 0;

  Player player{ 100, Screen::Height / 2 }; // 自機の初期化
  std::shared_ptr<Player> player{ std::make_shared<Player>(100, Screen::Height / 2, this) }; // 自機の初期化
  //↑プレイヤを回し読みポインタ型に。std::make_shared<Player>でメモリ上に実体を生成
  std::vector<std::shared_ptr<PlayerBullet>> playerBullets; // 自機弾のリスト
  //可変長配列vector ↑【shared_ptr:共有ポインタ】

  // ★【shared_ptr:共有ポインタ】とは【データの回し読み(読まれなくなったら廃棄)】
  // 「例えば、兄弟で週刊少年ジャンプを【回し読みするときは】
  // おかんに【全員読み終わるまではメモリから捨てられないように】する
  // 【読むつもりの人のカウンタ.use_count()】がゼロになると【おかんに捨てられる(リンク切れはメモリから廃棄する)】」

};

#endif

次にGame.cppファイルにUpdateとDrawに自機弾更新と描画の処理を追加しましょう。

Game.cppの内容を次のようにします：

#include "Game.h"

#include "PlayerBullet.h" // ★Update(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  Image::Load(); //画像の読込み
  x = 100; // Xの初期位置
  vx = 10;
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  if (x < 0)
  {
    vx = 10; //速度の変更
  }
  else if (x > Screen::Width)
  {
    vx = -10;
  }
  x += vx; // X位置の更新

  player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】
  //ポインタ↑になると.から->でのアクセスになる

  // 自機弾の更新処理
  // for文で全自機弾をループで回してUpdateで更新
  for (const auto& b : playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }
  
  
  //【放置厳禁！！！このままここに弾の削除処理書かないとメモリがどんどん減ってくよ(気づかないうちにどんどん使用メモリが増える..怖)】
  
  
};

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 0.9f, 0, Image::bossImage, TRUE);

  player->Draw(); // プレイヤの更新【忘れるとプレイヤ表示されない】
  //ポインタ↑になると.から->でのアクセスになる

  // 自機弾の描画処理
  // for文で全自機弾をループで回してUpdateで更新
  for (const auto& b : playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Draw();
  }
};

Player.hにPlayerBulletへの参照を得るためGameへのポインタ参照を追加します：

#ifndef PLAYER_H_
#define PLAYER_H_

#include "DxLib.h"
#include "Input.h"
#include "Image.h"
#include "MyMath.h"

class Game; //←【エラー地獄に注意！】ここにGameクラスがあるものとして書くことで【循環相互インクルード問題】を回避

//↑Gameクラス内にPlayer変数を持っているからPlayerの定義が終わらないとGameの定義が完了しない(未定義エラー)
//【なのに】Playerクラス内にGame変数を持っているからPlayerの定義も終わらない！！(未定義エラー)
//【つまりPlayerとGameが互いに定義が終わるのを待つ】【循環相互インクルードどうぞどうぞ状態】になる
//【解決するために】とりあえずclass Game;とだけここに書いてGameは定義完了済と見せかけているわけです！
//[エラー:Playerは未定義です]とか[エラー:Gameは未定義です]とか定義してるはずのものが未定義の場合は大体これ！！

class Player
{
public:
  const float MoveSpeed = 6; // 移動速度

  float x; // x座標
  float y; // y座標

  Game* game { nullptr }; // Gameのインスタンスの参照
  //↑ * ポインタ型です！プレイヤの【内部に】ゲームの情報を【メモリ実体として持つ】と
  //そのプレイヤを親のゲームがもつと【延々とループで終わりなきメモリ爆発ループ】になるから
  //メモリに対しての参照=【レコードの針をGameに指して】【Gameの住所アドレスだけをプレイヤ内部に持つ】

  // コンストラクタ
  // x : 初期位置x
  // y : 初期位置y
  Player(float x, float y, Game* game)
  {
    this->x = x;
    this->y = y;
    this->game = game;
  }

  // 更新処理
  void Update();//【★←Player.cppを新規作成してそちらに処理を書き移す】

  // 描画処理
  void Draw();//【★←Player.cppを新規作成してそちらに処理を書き移す】

};

#endif

↑Player.hにあった上記処理部分を↓Player.cppを新規作成して書き移します

Player.cppにPlayerBulletの発射処理を追加します：

#include "Player.h"

#include "Game.h" // ★game->playerBulletsなどClass Game;でカバーできない【定義の内部のplayerBulletsにアクセスするのでインクルード必要】
#include "PlayerBullet.h" // ★弾を生成して【使う処理があるのでインクルード必要】



// 更新処理【書き移す際にはPlayer::という形で::所属が必要になります】
void Player::Update()
{
  float vx = 0; // x方向移動速度
  float vy = 0; // y方向移動速度

  if (Input::GetButton(PAD_INPUT_LEFT))
  {
    vx = -MoveSpeed; // 左
  }
  else if (Input::GetButton(PAD_INPUT_RIGHT))
  {
    vx = MoveSpeed; // 右
  }
  if (Input::GetButton(PAD_INPUT_UP))
  {
    vy = -MoveSpeed; // 上
  }
  else if (Input::GetButton(PAD_INPUT_DOWN))
  {
    vy = MoveSpeed; // 下
  }

  // 斜め移動も同じ速度になるように調整
  if (vx != 0 && vy != 0)
  {
    vx /= MyMath::Sqrt2;
    vy /= MyMath::Sqrt2;
  }

  // 実際に位置を動かす
  x += vx;
  y += vy;

  // ボタン押下で自機弾を発射
  if (Input::GetButtonDown(PAD_INPUT_1))
  {
    // emplace_backで配列に追加。make_shared↓でプレイヤ弾を新しく生成
    game->playerBullets.emplace_back(std::make_shared<PlayerBullet>(x, y));
  }
}

// 描画処理
void Player::Draw()
{
  DrawRotaGraphF(x, y, 1, 0, Image::player, TRUE);
}

【確認してみましょう】ここまでで一旦弾が打てるかチェックしてみましょう！【メモリは削除されないバージョンなので要注意！！】

循環参照・インクルードの罠

【さてここで大量のエラーで詰んだ人も多いのでは】おそらくは【Player.hに弾を弾を撃つ処理を書いたのでは】

それにしても【なぜヘッダh.ファイルとcppファイルに書く違いだけで大量のエラー】が出てしまうのでしょう？

原因である【循環参照・循環インクルード】について説明します。
実はインクルードしたPlayer.hやGame.hは【⇒ビルド】した際に【Player.hの中身が#include "Player.h"へとコピペ】されるのです
そして問題は相互に【Player.hで#include "Game.h"】⇔【Game.hで#include "Player.h"】すると
互いへの【コピペがループする】ため【延々とGameかPlayerの定義が完成せず】
結果、邪悪なことに【全然関係ないPlayerBulletが未定義などと、とばっちりエラーが起こる】のです

さてこの【循環参照・循環インクルード】への対策をどうするかが問題です。

【1】 ヘッダ.hでのインクルードを避け.cppファイルでインクルードするのが基本的には有効です(ヘッダ.h同士が相互にコピペしあわないから)
【2】 しかし根本的には【★相互に参照しあう構造の設計自体すっきりさせたい】です。

今はPlayer⇔Gameの1対1の関係でまだ把握可能ですが、ザコや敵の弾などが他に増えてくると
恐怖の三角関係や四角関係など【どこかで一周回ると無限インクルード発生】が起こってきます。
まだ【1対1の循環なら見抜ける】けど【★三角ループや四角ループは発見が難しすぎ】です。

そう、相互に行き来する【★矢印を一つへ集中させる】のです。
こういったパターンを【★仲介者(Meditator:メディエーター)パターン】あるいは【★窓口(Facade:ファサード)パターン】と呼びます。
このパターンは【循環参照問題以外にも色んな利点】があり多用されます。
一点に集中させれば【メモリの状況もここに集中します】し
ここを経由すれば【どこからでもどこへでも連絡でき指令が出せます】
そしていちいち初期化の時に【参照の連絡先の交換が必要なくなります】

ついでにもう一つ【★唯一物(シングルトン)パターン】も取り入れておきます。

こういった先人の生み出したパターンを【デザインパターン】といいます。

有用なデザインパターンは23ほどあり、状況に合わせてうまく取り入れることが上級者への道で
変な構造で作っていると起こる面倒な時間のロスが減り【残業時間が減ります】
案外【ブラックな現場は構造のデザインそのものが悪かった】ことも多いです(なんかいちいちやりづらい環境)
こういう【構造自体に疑問を持てる人が開発のリーダーシップを取れる】と心地よく制作が進むので
時間とスキルに余裕ができたら将来のリーダーに向けて【デザイン構造パターン】を勉強するとよいかもしれません。

さて、ではまずSingleton.hを追加しましょう。
コード中身は難しい文法が多いですが、
基本の要点は

【1】「代入」「コピー」「実体ポインタへの直接アクセス」を★private:として【外部から禁止】
【2】「実体へは★GetInstance()関数経由でしかアクセスできない」よう窓口を絞り
【3】「テンプレ化」★template<class T>して何でも唯一化できるようになっています

シングルトン型:唯一物体タイプの追加

難しいコードなので導入するだけでも良いですが、
C++の「代入」「コピー」「テンプレ化」は基礎として大事なので頑張って6割ほどは理解できるようになりたいですね。
2,3年後上級者となって読み返して9割ほど理解できるようになるよう成長してゆきましょう。

Singleton.h

#ifndef SINGLETON_H_
#define SINGLETON_H_

// テンプレートT型シングルトンSingleton<～> ～になんでも指定して唯一物にできる
// ★Singleton<T>型は【必ず唯一で複製不可】(使い方:どこからでもアクセスし変数を共有するクラス向き)
// ★ゲーム内の【どこからアクセスしても統一性が保たれる】(唯一だから)「クラス名と実体が一致」
template<class T>
class Singleton
{
public:
  // GetInstanceを通して【しか】T型クラスをつくれないうえに、
  // ★作ったものは【かならず唯一で複製不可】
  // それが【シングルトン型】！
  // ゲーム中で唯一で複製不可にしたい【ゲームを一律管理するクラス】などに最適！
  // https://teratail.com/questions/17416
  // http://rudora7.blog81.fc2.com/blog-entry-393.html
  // ②↓同じ関数の定義はプログラム全体で１つだけしか許されません。(static関数名は被らない)
  static inline T& GetInstance()
  {  //①↓関数の中で定義されたstatic変数は、関数の定義毎に１つ領域が確保されます。
    static T instance; //メモリ上にstatic変数確保(静かに常に待機するinstance)
    return instance; //①=(常駐)②=(唯一) ①と②両方満たすinstanceは【メモリ上に唯一】
  }
  //★【{}内のローカルstaticの特性:ラベル(上の例ではinstance)がリセットされずに常駐】https://monozukuri-c.com/langc-static-memory/
  //つまり、ゲームマネージャなどを★リセットされず常駐状態にできるわけです

protected:
  Singleton() {} // 外部でのインスタンス作成は禁止(protected:内部公開、外部禁止)
  virtual ~Singleton() {} // 仮想デストラクタ(シングルトンを【継承するためには忘れちゃダメ】)

private:  //代入やコピーをprivateにして外部クラスからアクセスできないように【縛る】
  void operator=(const Singleton& obj) {} // 代入演算子禁止
  Singleton(const Singleton& obj) {} // コピーコンストラクタ禁止(コピーできない【唯一】)
  static T* instance; // private:だから外部アクセスできない【GetInstance()経由しかアクセスできないように縛る】
};

// いつもcppで書いたstatic変数初期化も★【Tテンプレートクラスだからすべて.hヘッダにまとめて書いた】
template< class T >
T* Singleton< T >::instance = 0; //cppでの定義を.h内に書いた(static変数はclass内で初期化できないから)

#endif

仲介マネージャーGameManagerの追加

続いて仲介の役割を担当するGameManager.hを作成します。

#ifndef GAMEMANAGER_H_
#define GAMEMANAGER_H_

#include <memory>
#include <vector>

#include "Singleton.h"

class Player; // クラス宣言だけで★インクルードしないのでこのマネージャファイルで循環は止まる
class PlayerBullet;

class GameManager : public Singleton<GameManager>//←<～>として継承すると唯一のシングルトン型タイプとなる
{
public:
  friend class Singleton<GameManager>; // Singleton でのインスタンス作成は許可

  std::shared_ptr<Player> player{ nullptr }; // 自機の初期化

  std::vector<std::shared_ptr<PlayerBullet>> playerBullets; // 自機弾のリスト
  // 複数リスト↑vector ↑【shared_ptr】回し読みポインタ:メモリにデータを回し読み状態として確保できる

protected:
  GameManager() {}; // 外部からのインスタンス作成は禁止
  virtual ~GameManager() {}; //外部からのインスタンス破棄も禁止
};

#endif

Game.hからGameManager.hに移行した処理を消して代わりにGameMangerへの連絡先gmを確保します。

#ifndef GAME_H_
#define GAME_H_

#include <vector>//配列 std::vectorを使う
#include <memory>//スマートなポインタを使うのに必要(shared_ptrなど)

#include "Image.h"
#include "Screen.h"
#include "Player.h"

//前方宣言でPlayerBulletという【ポインタの型】があることだけを宣言すれば#includeせずにstd::vectorの中身にPlayerBulletのリンクだけなら入れられる
class PlayerBullet;

#include "GameManager.h"

class Game
{
public :
  Game() {}; // 初期化コンストラクタ
  ~Game() {}; // 破棄処理デストラクタ

  //★【仲介者パターン】ゲーム内のもの同士はマネージャを通して一元化してやり取り
  GameManager& gm = GameManager::GetInstance(); //唯一のゲームマネージャへの参照(&)を得る

  void Init(); // Init処理(定義だけ)
  void Update(); // 更新処理(定義だけ)
  void Draw();// 描画処理(定義だけ)

  int x = 0;
  int vx = 0;

  std::shared_ptr<Player> player{ std::make_shared<Player>(100, Screen::Height / 2, this) }; // 自機の初期化
  //↑プレイヤを回し読みポインタ型に。std::make_shared<Player>でメモリ上に実体を生成
  std::vector<std::shared_ptr<PlayerBullet>> playerBullets; // 自機弾のリスト

};

#endif

次にGame.cppファイルのPlayerやPlayerBulletのアクセスをGamaManagerのgm経由に書き換えましょう。

Game.cppの内容を次のように変更します：

#include "Game.h"

#include "Player.h" // ★初期化やUpdate(),Draw()など【実際の処理の関数を呼出すのでインクルード必要】
#include "PlayerBullet.h" // ★Update(),Draw()など【実際の処理の関数を呼出すのでインクルード必要】

void Game::Init()
{// Init処理

  Image::Load(); //画像の読込み
  x = 100; // Xの初期位置
  vx = 10;

  gm.player = std::make_shared<Player>((float)100, (float)(Screen::Height / 2)); // 自機の初期化
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  if (x < 0)
  {
    vx = 10; //速度の変更
  }
  else if (x > Screen::Width)
  {
    vx = -10;
  }
  x += vx; // X位置の更新

  gm.player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】
  //ポインタ↑になると.から->でのアクセスになる

  // 自機弾の更新処理
  // C#のforeach文と同じく全自機弾を更新できる
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }
  
  
  //【放置厳禁！！！このままここに弾削除処理書かないとメモリがどんどん減ってくよ(気づかないうちにね..怖)】
  
  
};

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 0.9f, 0, Image::bossImage, TRUE);

  gm.player->Draw(); // プレイヤの更新【忘れるとプレイヤ表示されない】
  //ポインタ↑になると.から->でのアクセスになる

  // 自機弾の描画処理
  // C#のforeach文と同じく全自機弾を更新できる
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Draw();
  }
};

Player.hもGameManagerのgm経由でのアクセスにするので#include "Game.h"やGame*のポインタはなくなります。

#ifndef PLAYER_H_
#define PLAYER_H_

#include "DxLib.h"
#include "Input.h"
#include "Image.h"
#include "MyMath.h"

class Game;//←【エラー地獄に注意！】ここにGameクラスがあるものとして書くことで【循環相互インクルード問題】を回避

#include "GameManager.h"

class Player
{
public:
  const float MoveSpeed = 6; // 移動速度

  float x; // x座標
  float y; // y座標

  //★【仲介者パターン】ゲーム内のもの同士はマネージャを通して一元化してやり取り
  GameManager& gm = GameManager::GetInstance(); //唯一のゲームマネージャへの参照(&)を得る

  Game* game { nullptr }; // Gameのインスタンスの参照
  //↑ * ポインタ型です！プレイヤの【内部に】ゲームの情報を【メモリ実体として持つ】と
  //そのプレイヤを親のゲームがもつと【延々とループで終わりなきメモリ爆発ループ】になるから
  //メモリに対しての参照=【レコードの針をGameに指して】【Gameの住所アドレスだけをプレイヤ内部に持つ】

  // コンストラクタ
  // x : 初期位置x
  // y : 初期位置y
  Player(float x, float y, Game* game)
  {
    this->x = x;
    this->y = y;
    this->game = game;
  }

  // 更新処理の関数定義
  void Update();

  // 描画処理の関数定義
  void Draw();

};

#endif

Player.cppもGameManagerのgm経由でのアクセスに書き換えます

#include "Player.h"

#include "Game.h"
#include "PlayerBullet.h" // ★弾を生成して【使う処理があるのでインクルード必要】

// 更新処理【書き移す際にはPlayer::という形で::所属が必要になります】
void Player::Update()
{
  float vx = 0; // x方向移動速度
  float vy = 0; // y方向移動速度

  if (Input::GetButton(PAD_INPUT_LEFT))
  {
    vx = -MoveSpeed; // 左
  }
  else if (Input::GetButton(PAD_INPUT_RIGHT))
  {
    vx = MoveSpeed; // 右
  }
  if (Input::GetButton(PAD_INPUT_UP))
  {
    vy = -MoveSpeed; // 上
  }
  else if (Input::GetButton(PAD_INPUT_DOWN))
  {
    vy = MoveSpeed; // 下
  }

  // 斜め移動も同じ速度になるように調整
  if (vx != 0 && vy != 0)
  {
    vx /= MyMath::Sqrt2;
    vy /= MyMath::Sqrt2;
  }

  // 実際に位置を動かす
  x += vx;
  y += vy;

  // ボタン押下で自機弾を発射
  if (Input::GetButtonDown(PAD_INPUT_1))
  {
    // emplace_backで配列に追加。make_shared↓でプレイヤ弾を新しく生成
    gm.playerBullets.emplace_back(std::make_shared<PlayerBullet>(x, y));
  }
}

// 描画処理
void Player::Draw()
{
  DrawRotaGraphF(x, y, 1, 0, Image::player, TRUE);
}

【※メモリから弾を削除】自機弾PlayerBulletの削除処理

PlayerBulletクラスを改造しましょう。

PlayerBullet.hの内容を次のように【改造】します：

#ifndef PLAYERBULLET_H_
#define PLAYERBULLET_H_

#include "DxLib.h"
#include "Image.h"
#include "Screen.h"

// 自機弾クラス
class PlayerBullet
{
public:
  const float Speed = 25; // 移動速度
  const int VisibleRadius = 16; // 見た目の半径
  
  // ↓【使用要注意！(テスト用！！)】メモリ消費弾(4MB)撃つたびに4MB消費(下の行のコメント外すと)
  //【使用注意】int memMUDA[1000000]; // 4バイト×1000000= 4MBの無駄メモリ

  float x; // x座標
  float y; // y座標
  bool isDead = false; // 死亡フラグ

  // コンストラクタ
  PlayerBullet(float x, float y)
  {
    this->x = x;
    this->y = y;
  }

  // 更新処理
  void Update()
  {
    // 移動
    x += Speed;
    
    // 画面外に出たら、死亡フラグを立てる
    if (x - VisibleRadius > Screen::Width)
    {
      isDead = true;
    }
  }

  // 描画処理
  void Draw()
  {
    DrawRotaGraphF(x, y, 1, 0, Image::playerBullet,TRUE);
  }
};


#endif

次にGame.cppファイルに自機弾PlayerBulletの【削除処理】を追加しましょう。

Game.cppの内容を次のようにします：

#include "Game.h"
#include "Player.h" // ★初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // ★Update(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  Image::Load(); //画像の読込み
  x = 100; // Xの初期位置
  vx = 10;

  gm.player = std::make_shared<Player>((float)100, (float)Screen::Height / 2); // 自機の初期化
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  if (x < 0)
  {
    vx = 10; //速度の変更
  }
  else if (x > Screen::Width)
  {
    vx = -10;
  }
  x += vx; // X位置の更新

  gm.player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】

  // 自機弾の更新処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }
  
  
  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾のリストから死んでるものを除去する
  // 非常に複雑な式に見えるがこれでisDeadのものを削除
  // https://stackoverflow.com/questions/42723205/remove-if-from-a-stdvector-of-shared-pointers-with-a-member-function
  gm.playerBullets.erase(
    std::remove_if(gm.playerBullets.begin(), gm.playerBullets.end(),
      [](std::shared_ptr<PlayerBullet> &ptr) {
        //int usingCount = -1;//テスト用コード(以下のコメントアウト部分は省略可)
        //if (ptr->isDead) usingCount = ptr.use_count();//おかんのコレ捨てるよカウンタ
        //弾を捨てるまでの残り↑カウント(1だとisDeadがtrueなら0になり削除へ
        return ptr->isDead;
      }),
    gm.playerBullets.end()
  );
};

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 0.9f, 0, Image::bossImage, TRUE);

  gm.player->Draw(); // プレイヤの更新【忘れるとプレイヤ表示されない】

  // 自機弾の描画処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Draw();
  }
};

さて、削除部分の処理が非常に複雑ですね。C#と比較してみましょう。
【C#】
playerBullets.RemoveAll(pb => pb.isDead);
【C++】

gm.playerBullets.erase(
  std::remove_if(gm.playerBullets.begin(), gm.playerBullets.end(),
    [](std::shared_ptr<PlayerBullet> &ptr) {
      //int usingCount = -1;//テスト用コード(以下のコメントアウト部分は省略可)
      //if (ptr->isDead) usingCount = ptr.use_count();//おかんのコレ捨てるよカウンタ
      //弾を捨てるまでの残り↑カウント(1だとisDeadがtrueなら0になり削除へ
      return ptr->isDead;
    }),
  gm.playerBullets.end()
);

gm.playerBullets.erase(
  std::remove_if(gm.playerBullets.begin(), gm.playerBullets.end(),
    [](std::shared_ptr<PlayerBullet> &ptr) {
      return ptr->isDead;
    }),
  gm.playerBullets.end()
);

gm.playerBullets.erase(
  ……
    ……
      ……
    ……,
  gm.playerBullets.end()
);

[](std::shared_ptr<PlayerBullet> &ptr) { return ptr->isDead; }

しかし、なぜ【わざわざeraseとremove_ifを組合わせる必要があるのか】
それは【erase単体だけだと削除処理が遅い】からです。
vectorはメモリ上にデータが【隙間なく詰まってます】ゆえに【通常性能は速いです】
ただ引き換えに【あいだのデータを1個消す】だけで【隙間を埋める座席移動が発生】します。
100万のデータが座ってる中、中央付近のデータを1個消すだけで【50万回ぶん一つずつ隙間を埋める座席移動が発生】します。
これがeraseだけ異様に遅い理由です。
逆に映画館の座席で通路付近に座ってる人を思い浮かべてください。
映画が終わると通路付近の座席の人はすぐに立って横に出れば最初に通路への出られますよね。
ゆえに配列の【後ろから】一つ削除する【pop_back処理は速い】です。
したがって【後ろに消したいものを先に集めてしまえばよいのです】
これが【remove_if】処理です。remove_ifは条件を指定して【削除候補を後ろに並べ替えます】
ゆえに【2】remove_ifで先に後ろに並べ替えて【1】eraseでまとめて削除の【1】【2】のハイブリッドが必要なのです。

ただ、毎回この複雑なコードを書くと【コードが見にくくなる】ので【テンプレート化】に挑戦してみましょう。

共通削除機能を【テンプレートとして定義】

GameManager.hに共通の削除機能として【テンプレート機能】として追加してみましょう。

#ifndef GAMEMANAGER_H_
#define GAMEMANAGER_H_

#include <memory>
#include <vector>

#include "Singleton.h"

class Player; // クラス宣言だけで★インクルードしないのでこのマネージャファイルで循環は止まる
class PlayerBullet;

class GameManager : public Singleton<GameManager>//←<～>として継承すると唯一のシングルトン型タイプとなる
{
public:
  friend class Singleton<GameManager>; // Singleton でのインスタンス作成は許可

  std::shared_ptr<Player> player{ nullptr }; // 自機の初期化

  std::vector<std::shared_ptr<PlayerBullet>> playerBullets; // 自機弾のリスト
  // 複数リスト↑vector ↑【shared_ptr】回し読みポインタ:メモリにデータを回し読み状態として確保できる



  // ★削除処理を共通テンプレート関数にする
  // [共通テンプレート関数]https://programming-place.net/ppp/contents/cpp/language/009.html#function_template
  template <typename T, class T_if>
  void EraseRemoveIf(std::vector<T> &v, T_if if_condition)
  {   //            特定のタイプT↑  ↑配列v   ↑条件式if_condition
    v.erase(
      std::remove_if(v.begin(), v.end(),if_condition),
      v.end() //  ↓remove_ifの位置
    );//例.[生][生][死][死][死]← v.end()の位置
  };

protected:
  GameManager() {}; // 外部からのインスタンス作成は禁止
  virtual ~GameManager() {}; //外部からのインスタンス破棄も禁止
};

#endif

そしてGame.cppの削除処理をシンプルに書き直します

#include "Game.h"
#include "Player.h" // ★初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // ★Update(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  Image::Load(); //画像の読込み
  x = 100; // Xの初期位置
  vx = 10;

  gm.player = std::make_shared<Player>((float)100, (float)Screen::Height / 2); // 自機の初期化
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  if (x < 0)
  {
    vx = 10; //速度の変更
  }
  else if (x > Screen::Width)
  {
    vx = -10;
  }
  x += vx; // X位置の更新

  gm.player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】

  // 自機弾の更新処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }
  
  
  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾の削除処理
  gm.EraseRemoveIf(gm.playerBullets,
    [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
  // 自機弾のリストから死んでるものを除去する
  // 非常に複雑な式に見えるがこれでisDeadのものを削除
  // https://stackoverflow.com/questions/42723205/remove-if-from-a-stdvector-of-shared-pointers-with-a-member-function
  gm.playerBullets.erase(
    std::remove_if(gm.playerBullets.begin(), gm.playerBullets.end(),
      [](std::shared_ptr<PlayerBullet> &ptr) {
        //int usingCount = -1;//テスト用コード(以下のコメントアウト部分は省略可)
        //if (ptr->isDead) usingCount = ptr.use_count();//おかんのコレ捨てるよカウンタ
        //弾を捨てるまでの残り↑カウント(1だとisDeadがtrueなら0になり削除へ
        return ptr->isDead;
      }),
    gm.playerBullets.end()
  );
};

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 0.9f, 0, Image::bossImage, TRUE);

  gm.player->Draw(); // プレイヤの更新【忘れるとプレイヤ表示されない】

  // 自機弾の描画処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Draw();
  }
};

さて、使う側はすっきり2行にまとまりました。
これなら削除するリストがenemiesやenemyBulletsなど増えてきても書きやすいです。

テンプレート化template <typename T>を習得することは上級者への第一歩です。
C++だけでなく【C#でもテンプレート化ができます】ぜひ練習して習得してゆきましょう。
逆の目線で言うと【実は今まではテンプレート化された使いやすい機能を使わせてもらっていた】のです。意識せずに。
使う側が意識しなくていいほど【使いやすいテンプレート】を自力で作れることが理想形です。トライしてゆきましょう。

【実験】メモリ浪費弾の実験

ここまでで一応弾の削除処理は書けました。しかし本当に弾が削除されているか実感がありません。
弾1個は現状では【かなり微小なメモリしか】使用しません。
実行して【メモリのグラフを見ても増えているか減っているか見えないほど微小です】
そこで【人為的に弾1個のメモリを大きくする】実験をしてみましょう。
注意が必要です【危険な実験】です(ほったらかすと)。【実験コードは必ず元に戻してください！！】
では実験を始めてみましょう。

PlayerBullet.hの内容を次のように【改造】します：

#ifndef PLAYERBULLET_H_
#define PLAYERBULLET_H_

#include "DxLib.h"
#include "Image.h"
#include "Screen.h"

// 自機弾クラス
class PlayerBullet
{
public:
  const float Speed = 25; // 移動速度
  const int VisibleRadius = 16; // 見た目の半径
  
  // ↓【使用要注意！(テスト用！！)】メモリ消費弾(4MB)撃つたびに4MB消費(下の行のコメント外すと)
  int memMUDA[1000000]; // 4バイト×1000000= 4MBの無駄メモリ

  float x; // x座標
  float y; // y座標
  bool isDead = false; // 死亡フラグ

  // コンストラクタ
  PlayerBullet(float x, float y)
  {
    this->x = x;
    this->y = y;
  }

  // 更新処理
  void Update()
  {
    // 移動
    x += Speed;
    
    // 画面外に出たら、死亡フラグを立てる
    if (x - VisibleRadius > Screen::Width)
    {
      isDead = true;
    }
  }

  // 描画処理
  void Draw()
  {
    DrawRotaGraphF(x, y, 1, 0, Image::playerBullet,TRUE);
  }
};


#endif

無駄メモリをあえて人為的に定義して弾を撃ってみましょう。
メモリの【グラフがうなぎ上りに上昇しなければ】プレイヤの弾に関してはメモリの削除と開放が成功している証拠です。

試しにGame.cppで削除処理をわすれた場合の実験をしてみましょう。

#include "Game.h"
#include "Player.h" // ★初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // ★Update(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  Image::Load(); //画像の読込み
  x = 100; // Xの初期位置
  vx = 10;

  gm.player = std::make_shared<Player>((float)100, (float)Screen::Height / 2); // 自機の初期化
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  if (x < 0)
  {
    vx = 10; //速度の変更
  }
  else if (x > Screen::Width)
  {
    vx = -10;
  }
  x += vx; // X位置の更新

  gm.player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】

  // 自機弾の更新処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }
  
  
  return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾の削除処理
  //gm.EraseRemoveIf(gm.playerBullets,
  //  [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
};

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 0.9f, 0, Image::bossImage, TRUE);

  player->Draw(); // プレイヤの更新【忘れるとプレイヤ表示されない】

  // 自機弾の描画処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Draw();
  }
};

実験が終わったら実験コードをもとに戻しましょうPlayerBullet.hの内容を次のようにします

#ifndef PLAYERBULLET_H_
#define PLAYERBULLET_H_

#include "DxLib.h"
#include "Image.h"
#include "Screen.h"

// 自機弾クラス
class PlayerBullet
{
public:
  const float Speed = 25; // 移動速度
  const int VisibleRadius = 16; // 見た目の半径
  
  // ↓【使用要注意！(テスト用！！)】メモリ消費弾(4MB)撃つたびに4MB消費(下の行のコメント外すと)
  //【実験コード】int memMUDA[1000000]; // 4バイト×1000000= 4MBの無駄メモリ

  float x; // x座標
  float y; // y座標
  bool isDead = false; // 死亡フラグ

  // コンストラクタ
  PlayerBullet(float x, float y)
  {
    this->x = x;
    this->y = y;
  }

  // 更新処理
  void Update()
  {
    // 移動
    x += Speed;
    
    // 画面外に出たら、死亡フラグを立てる
    if (x - VisibleRadius > Screen::Width)
    {
      isDead = true;
    }
  }

  // 描画処理
  void Draw()
  {
    DrawRotaGraphF(x, y, 1, 0, Image::playerBullet,TRUE);
  }
};


#endif

Game.cppの削除処理ももとに戻しましょう。

#include "Game.h"
#include "Player.h" // ★初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // ★Update(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  Image::Load(); //画像の読込み
  x = 100; // Xの初期位置
  vx = 10;

  gm.player = std::make_shared<Player>((float)100, (float)Screen::Height / 2); // 自機の初期化
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  if (x < 0)
  {
    vx = 10; //速度の変更
  }
  else if (x > Screen::Width)
  {
    vx = -10;
  }
  x += vx; // X位置の更新

  gm.player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】

  // 自機弾の更新処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }
  
  
  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾の削除処理
  gm.EraseRemoveIf(gm.playerBullets,
    [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
};

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 0.9f, 0, Image::bossImage, TRUE);

  player->Draw(); // プレイヤの更新【忘れるとプレイヤ表示されない】

  // 自機弾の描画処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Draw();
  }
};

自機弾の角度を変えられるようにする

PlayerBullet.hに角度をつけられるようにします

#ifndef PLAYERBULLET_H_
#define PLAYERBULLET_H_

#include <cmath> //sin,cosを使うのに必要

#include "DxLib.h"
#include "Image.h"
#include "Screen.h"

// 自機弾クラス
class PlayerBullet
{
public:
  const float Speed = 25; // 移動速度
  const int VisibleRadius = 16; // 見た目の半径
  
  // ↓【使用要注意！(テスト用！！)】メモリ消費弾(4MB)撃つたびに4MB消費(下の行のコメント外すと)
  //【実験コード】int memMUDA[1000000]; // 4バイト×1000000= 4MBの無駄メモリ

  float x; // x座標
  float y; // y座標
  bool isDead = false; // 死亡フラグ

  float vx; // x方向移動速度
  float vy; // y方向移動速度
  float angle; // 移動角度

  // コンストラクタ
  PlayerBullet(float x, float y, float angle)
  {
    this->x = x;
    this->y = y;

    this->angle = angle;
    vx = (float)std::cos(angle) * Speed;
    vy = (float)std::sin(angle) * Speed;
  }

  // 更新処理
  void Update()
  {
    // 移動
    x += vx;
    y += vy;
    
    // 画面外に出たら、死亡フラグを立てる
    if (x + VisibleRadius < 0 || x - VisibleRadius > Screen::Width ||
      y + VisibleRadius < 0 || y - VisibleRadius > Screen::Height)
    {
      isDead = true;
    }
  }

  // 描画処理
  void Draw()
  {
    DrawRotaGraphF(x, y, 1, angle, Image::playerBullet,TRUE);
  }
};


#endif

MyMath.hを編集します：

#ifndef _MYMATH_H
#define _MYMATH_H
// 数学関連クラス
class MyMath
{
public:
  static const float Sqrt2;  // = 1.41421356237f;(.hではfloat小数型の初期化はできない int型はできるのに)
  static const float PI; // 円周率 3.14159265359f;
  static const float Deg2Rad; // 度からラジアンに変換する定数 PI / 180f;

}; // 【注意】セミコロン抜けで【宣言が必要ですエラー】

#endif //【宣言が必要ですエラーは上のセミコロン抜け】

MyMath.cppを編集して変数に数値を割り当て。

#include "MyMath.h"

const float MyMath::Sqrt2 = 1.41421356237f;//(floatは有効桁は実質7桁まで正確だがそれ以降は環境によって誤差出る)
const float MyMath::PI = 3.14159265359f; // 円周率
const float MyMath::Deg2Rad = MyMath::PI / 180; // 度からラジアンに変換する定数

Player.cppのプレイヤの弾の生成を改修します。

#include "Player.h"
#include "MyMath.h"

(前略)...................................

  // ボタン押下で自機弾を発射
  if (Input::GetButtonDown(PAD_INPUT_1))
  {
    // C++ではAddがemplace_backに↓ newがmake_shared↓に
    gm.playerBullets.emplace_back(std::make_shared<PlayerBullet>(x, y, 0));//右
    gm.playerBullets.emplace_back(std::make_shared<PlayerBullet>(x, y, -15 * MyMath::Deg2Rad));//右上
    gm.playerBullets.emplace_back(std::make_shared<PlayerBullet>(x, y, +15 * MyMath::Deg2Rad));//右下
  }
}

(以下略)

vectorとlistの性能考察

GameManager.hで管理しているPlayerBulletのvector配列をlist構造に変更してみましょう。

#ifndef GAMEMANAGER_H_
#define GAMEMANAGER_H_

#include <memory>
#include <vector>
#include <list>

#include "Singleton.h"

class Player; // クラス宣言だけで★インクルードしないのでこのマネージャファイルで循環は止まる
class PlayerBullet;

class GameManager : public Singleton<GameManager>//←<～>として継承すると唯一のシングルトン型タイプとなる
{
public:
  friend class Singleton<GameManager>; // Singleton でのインスタンス作成は許可

  std::shared_ptr<Player> player{ nullptr }; // 自機の初期化

  std::list<std::shared_ptr<PlayerBullet>> playerBullets; // 自機弾のリスト
  // 複数リスト↑list ↑【shared_ptr】回し読みポインタ:メモリにデータを回し読み状態として確保できる



  // ★削除処理を共通テンプレート関数にする
  // [共通テンプレート関数]https://programming-place.net/ppp/contents/cpp/language/009.html#function_template
  template <typename T, class T_if>
  void EraseRemoveIf(std::list<T> &v, T_if if_condition)
  {   //            特定のタイプT↑  ↑配列v   ↑条件式if_condition
    v.erase(
      std::remove_if(v.begin(), v.end(),if_condition),
      v.end()   
    ); 
  };

protected:
  GameManager() {}; // 外部からのインスタンス作成は禁止
  virtual ~GameManager() {}; //外部からのインスタンス破棄も禁止
};

#endif

ベクトル構造体でX,Y,ZをVector3型でまとめて管理する

ベクトルの基本

ベクトルの計算

敵の作成【共通のGameObjectを継承する】

Enemyクラスを作成するにあたって共通の基底(ベース)クラスとなるGameObjectを導入する

Enemyクラスを定義してそれを継承する形でZako0をつくることもできますが
その構造で作り進めると循環参照インクルードが起こってしまいがちです。
なぜなら、衝突判定で【PlayerBullet⇔Enemy⇔Playerの相互の矢印の参照ループが生まれやすくなります】
そこで共通の基底(ベース)クラスとなるGameObject、すなわち全てのものが継承する【ベースとなる継承元】を導入します。
これで矢印はGameObjectにまとまりオブジェクト同士の参照をせずに済みます。

共通のベースとなるGameObjectを作成する

Zako0クラスの作成

Zako0.hを作成します。

#ifndef ZAKO_0_H_
#define ZAKO_0_H_

#include "Enemy.h"
#include "Image.h"

// ザコ0クラス
class Zako0 : public Enemy
{
public:
  // コンストラクタ
  Zako0(Vector3 pos)
    : Enemy( pos )
  {
    this->tag = "Zako0";
  }

  // 更新処理
  void Update() override
  {
    position.x -= 1; // とりあえず左へ移動
  }

  // 描画処理
  void Draw() override
  {
    DrawRotaGraphF(position.x, position.y, 1, 0, Image::zako0, TRUE);
  }
};

#endif

Image.hにザコ0,1,2,3と敵弾の画像定義を追加します：

#ifndef IMAGE_H_
#define IMAGE_H_

#include "DxLib.h"
#include <assert.h> // 画像読み込みの読込み失敗表示用

class Image
{
public:
  Image() {}; // 初期化コンストラクタ:定義と{}空の処理
  ~Image() {}; // 破棄する処理デストラクタ:定義と{}空の処理
  static void Load();

  static int bossImage; //ボス画像のハンドラ(読込画像番号)
  static int player; //プレイヤ画像のハンドラ
  static int playerBullet; //プレイヤの弾画像のハンドラ
  static int enemyBullet16; //敵弾 画像のハンドラ(読込画像番号)
  static int zako0; //ザコ0 画像のハンドラ(読込画像番号)
  static int zako1; //ザコ1 画像のハンドラ(読込画像番号)
  static int zako2; //ザコ2 画像のハンドラ(読込画像番号)
  static int zako3; //ザコ3 画像のハンドラ(読込画像番号)

private:

};
#endif

次に対となるcppファイルも変更します。
Image.cppの内容を次のようにします：

#include "Image.h"

int Image::bossImage{-1}; // Load終わっても-1(初期値)のままだと画像ロードが失敗してますね
int Image::player{-1};
int Image::playerBullet{-1};
int Image::enemyBullet16{-1};
int Image::zako0{-1};
int Image::zako1{-1};
int Image::zako2{-1};
int Image::zako3{-1};

void Image::Load()
{
  bossImage = LoadGraph("Image/boss1.png");
  assert(bossImage != -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  player= LoadGraph("Image/player.png");
  assert(player!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  playerBullet = LoadGraph("Image/player_bullet.png");
  assert(playerBullet!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  enemyBullet16 = LoadGraph("Image/enemy_bullet_16.png");
  assert(enemyBullet16!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako0 = LoadGraph("Image/zako0.png");
  assert(zako0!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako1 = LoadGraph("Image/zako1.png");
  assert(zako1!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako2 = LoadGraph("Image/zako2.png");
  assert(zako2!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako3 = LoadGraph("Image/zako3.png");
  assert(zako3!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる
}

敵を管理する仕組みの作成

GameManager.hに敵のリストを追加しましょう。

#ifndef GAMEMANAGER_H_
#define GAMEMANAGER_H_

#include <memory>
#include <vector>

#include "Singleton.h"

class Player; // クラス宣言だけで★インクルードしないのでこのマネージャファイルで循環は止まる
class PlayerBullet;
class Enemy;

class GameManager : public Singleton<GameManager>//←<～>として継承すると唯一のシングルトン型タイプとなる
{
public:
  friend class Singleton<GameManager>; // Singleton でのインスタンス作成は許可

  std::shared_ptr<Player> player{ nullptr }; // 自機のポインタ
  std::list<std::shared_ptr<PlayerBullet>> playerBullets; // 自機弾のリスト
  std::list<std::shared_ptr<Enemy>> enemies; // 敵のリスト
  // 複数リスト↑list ↑【shared_ptr】回し読みポインタ:メモリにデータを回し読み状態として確保できる


(中略)..............
protected:
  GameManager() {}; // 外部からのインスタンス作成は禁止
  virtual ~GameManager() {}; //外部からのインスタンス破棄も禁止
};

#endif

Game.cppに敵の生成と更新と描画処理を追加しましょう。

#include "Game.h"
#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  Image::Load(); //画像の読込み
  x = 100; // Xの初期位置
  vx = 10;

  gm.player = std::make_shared<Player>(Vector3((float)100, (float)Screen::Height / 2)); // 自機の初期化
  // とりあえず適当に敵を生成
  gm.enemies.emplace_back(std::make_shared<Zako0>(Vector3((float)600, (float)100)));
  gm.enemies.emplace_back(std::make_shared<Zako0>(Vector3((float)1000, (float)500)));
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  if (x < 0)
  {
    vx = 10; //速度の変更
  }
  else if (x > Screen::Width)
  {
    vx = -10;
  }
  x += vx; // X位置の更新

  gm.player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】

  // 自機弾の更新処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }
  
  // 敵の更新処理
  for (const auto& b : gm.enemies)
  {
    b->Update();
  }
  
  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  gm.EraseRemoveIf(gm.playerBullets,
    [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
};

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 0.9f, 0, Image::bossImage, TRUE);

  // 敵の描画処理
  for (const auto& b : gm.enemies)
  {
    b->Draw();
  }

  gm.player->Draw(); // プレイヤの更新【忘れるとプレイヤ表示されない】

  // 自機弾の描画処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Draw();
  }
};

[C++]シューティングゲーム 2

1. 敵と自機弾の当たり判定の作成
2. 敵に耐久力を持たせる(おまけでSinの波運動のコード例も)
3. 自機と敵の当たり判定
4. 自機のライフの作成
5. 敵弾の作成
   - 練習問題(MyRandomで±15度に散乱弾を撃つ敵キャラ)
   - 練習問題(やられると点滅後自爆する敵キャラ)



次のテキスト3はこちら。


[C++]シューティングゲーム 3

敵と自機弾の当たり判定の作成

当たり判定の式をMyMathクラスに定義します。

MyMath.hを編集します：

#ifndef _MYMATH_H
#define _MYMATH_H

#include "Vector3.h"

// 数学関連クラス
class MyMath
{
public:
  static const float Sqrt2;  // = 1.41421356237f;(.hではfloat小数型の初期化はできない int型はできるのに)
  static const float PI; // 円周率 3.14159265359f;
  static const float Deg2Rad; // 度からラジアンに変換する定数 PI / 180f;

  /// <summary>
  /// 円と円が重なっているかを調べる
  /// </summary>
  /// <param name="pos1">円1の中心</param>
  /// <param name="radius1">円1の半径</param>
  /// <param name="pos2">円2の中心</param>
  /// <param name="radius2">円2の半径</param>
  /// <returns>重なっていればtrue、重なっていなければfalseを返却する</returns>
  static bool CircleCircleIntersection(
    Vector3 pos1, float radius1,
    Vector3 pos2, float radius2)
  { //[2乗のまま < 比較すると高速] https://www.stmn.tech/entry/2016/06/15/033835
    return ((pos1 - pos2).sqrMagnitude()
      < (radius1 + radius2) * (radius1 + radius2));
  }
}; // 【注意】セミコロン抜けで【宣言が必要ですエラー】

#endif //【宣言が必要ですエラーは上のセミコロン抜け】

Enemy.hを改修します。当たり判定の半径を表す変数と、死亡フラグ、被弾時の処理を追加します。

#ifndef ENEMY_H_
#define ENEMY_H_

#include "GameObject.h"

#include "GameManager.h"

// 敵の基底クラス。
// 全ての敵は、このクラスを継承して作る。
// ★【勉強】abstract型はC++にない!!【純粋仮想関数】を使って作る
class Enemy : public GameObject
{
public:

  //【仲介者パターン】ゲーム内のもの同士はマネージャを通して一元化してやり取り
  GameManager& gm = GameManager::GetInstance(); //唯一のゲームマネージャへの参照(&)を得る

  float collisionRadius = 32; // 当たり判定の半径
  float life = 1; // 耐久力

  // コンストラクタ
  Enemy(Vector3 pos) : GameObject( pos ) // GameObjectをベースとして初期化処理を継承する
  {
    this->typeTag = "Enemy";
  }

  // 更新処理。派生クラスでオーバーライドして使う
  virtual void Update() = 0;//virtual ～ = 0;で【純粋仮想関数に】これで【C#のabstract型に】

  // 描画処理。派生クラスでオーバーライドして使う
  virtual void Draw() = 0; //virtual ～ = 0;で【純粋仮想関数に】【関数 = 0で未定義状態を表現】

  //【勉強】関数 = 0って何?と思った人は【関数もメモリ上では住所アドレスに過ぎない】ことを知ろう
  // ★関数 = 0はつまり関数の住所ポインタの針が【メモリ上の何かを針で参照してない(住所不定無処理)】
  // つまり【関数が未定義ってこと】＝【あいまい部分があるabstractクラスってこと】
  //http://etc2myday.jugem.jp/?eid=204
  //http://wisdom.sakura.ne.jp/programming/c/c54.html
  //逆にいうと【関数を配列】にするっていうトリッキーなこともできる!
  //http://www.ced.is.utsunomiya-u.ac.jp/lecture/2012/prog/p3/kadai3/virtualfunc2.php

  // 自機弾に当たったときの処理 関数の【★引数をGameObject型↓にすることで循環インクルード抑止】
  virtual void OnCollisionPlayerBullet(std::shared_ptr<GameObject> playerBullet)
  {
    life -= 1; // ライフを減らす

    // ライフが無くなったら、死亡
    if (life <= 0)
    {
      isDead = true;
    }
  }
};

#endif

PlayerBullet.hを改修します。当たり判定を表す変数を追加します。

#ifndef PLAYERBULLET_H_
#define PLAYERBULLET_H_

#include <cmath> //sin,cosを使うのに必要

#include "DxLib.h"
#include "Image.h"
#include "Screen.h"

#include "GameObject.h"

// 自機弾クラス
class PlayerBullet: public GameObject
{ // 継承は↑: public ～にする。publicをつけ忘れるとGameObjectの変数がすべてprivateとして継承されちゃう
public:
  const float Speed = 25; // 移動速度
  const int VisibleRadius = 16; // 見た目の半径
  

  float collisionRadius = 16; // 当たり判定の半径
  float angle; // 移動角度


  (中略)....................

  // 更新処理
  void Update()
  {
    (中略)....................
  }

  // 描画処理
  void Draw()
  {
    DrawRotaGraphF(x, y, 1, angle, Image::playerBullet,TRUE);
  }

  // 敵にぶつかった時の処理
  void OnCollisionEnemy(std::shared_ptr<GameObject> other)
  {
    isDead = true;
  }
};

#endif

Game.cppを改修します。自機弾と敵が当たっているか調べる処理を追加します。

#include "Game.h"
#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  (中略)..................
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  (中略)..................

  gm.player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】

  // 自機弾の更新処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }
  
  // 敵の更新処理
  for (const auto& b : gm.enemies)
  {
    b->Update();
  }
  
  // 自機弾と敵の衝突判定
  for(const auto& playerBullet : gm.playerBullets)
  {
    // 自機弾が死んでたらスキップする
    if (playerBullet->isDead)
      continue;

    for(const auto& enemy : gm.enemies)
    {
      // 敵が死んでたらスキップする
      if (enemy->isDead)
        continue;

      // 自機弾と敵が重なっているか？
      if (MyMath::CircleCircleIntersection(
        playerBullet->position, playerBullet->collisionRadius,
        enemy->position, enemy->collisionRadius))
      {
        // 重なっていたら、それぞれのぶつかったときの処理を呼び出す
        enemy->OnCollisionPlayerBullet(playerBullet);
        playerBullet->OnCollisionEnemy(enemy);

        // 衝突の結果、自機弾が死んだら、この弾のループはおしまい
        if (playerBullet->isDead)
          break;
      }
    }
  }
  
  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.playerBullets,
    [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除

  // 敵のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemies,
    [](std::shared_ptr<Enemy>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
};

void Game::Draw()
{// 描画処理
(以下略)............

敵に耐久力を持たせる(おまけでSinの波運動のコード例も)

Zako1.hのlifeを5にすることでZako1を硬くしてみましょう。
ついでにsinの波運動も試してみましょう。

Zako1.hを新規作成します。黄色の部分がZako0との違いです。

#ifndef ZAKO_1_H_
#define ZAKO_1_H_

#include "Enemy.h"

#include <cmath> // Sinの計算に使う
#include "MyMath.h"
#include "Image.h"

// ザコ1クラス
class Zako1 : public Enemy
{
public:
  float sinMove = 0; // Sinの動きをする際の0～360度
  float sinRadius = 70; // Sinの動きをするときの半径
  
  // コンストラクタ
  Zako1(Vector3 pos) : Enemy ( pos )
  {
    this->tag = "Zako1";//オブジェクトの種類判別タグ
    life = 5;
  }

  // 更新処理
  void Update() override
  {
    position.x -= 1; // 左へ移動

    float prevSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
    sinMove += 2.5f; // Sinの波運動の角度を進める
    float currentSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;

    // (前の角度でのY) - (今の角度でのY)の差を足すことで【ベースのyの位置 ± sinの動き】になる
    position.y += currentSinY - prevSinY; // 上下方向のSinの波運動
  }

  // 描画処理
  void Draw() override
  {
    DrawRotaGraphF(position.x, position.y, 1, 0, Image::zako1, TRUE);
  }
};

#endif

Game.cppにZako1の生成処理を追加します。

#include "Game.h"
#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako1.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  (中略)..................

  // とりあえず適当に敵を生成
  gm.enemies.emplace_back(std::make_shared<Zako0>(Vector3((float)600, (float)100)));
  gm.enemies.emplace_back(std::make_shared<Zako0>(Vector3((float)1000, (float)500)));
  gm.enemies.emplace_back(std::make_shared<Zako1>(Vector3((float)1000, (float)150)));
};

自機と敵の当たり判定

Player.hに当たり判定半径を定義します。

#ifndef PLAYER_H_
#define PLAYER_H_

#include "DxLib.h"
#include "Input.h"
#include "Image.h"
#include "MyMath.h"
#include "Vector3.h"

#include "GameObject.h"

#include "GameManager.h"

class Player : public GameObject
{ // 継承は↑: public ～にする。publicをつけ忘れるとGameObjectの変数がすべてprivateとして継承されちゃう
public:
  const float MoveSpeed = 6; // 移動速度

  float collisionRadius = 32; // 当たり判定半径

  //【仲介者パターン】ゲーム内のもの同士はマネージャを通して一元化してやり取り
  GameManager& gm = GameManager::GetInstance(); //唯一のゲームマネージャへの参照(&)を得る

  // コンストラクタ
  // pos : 初期位置
  Player(Vector3 pos) : GameObject( pos ) //【忘れると】GameObjectの初期化処理が飛ばされて大混乱！
  {
  }

  virtual ~Player() {}; // 仮想デストラクタ ※無いと【削除された関数を参照しようとしてますエラー】が出るかも
  // 更新処理の関数定義
  void Update();

  // 描画処理の関数定義
  void Draw();

  // 敵にぶつかった時の処理
  void OnCollisionEnemy(std::shared_ptr<GameObject> other);
};

#endif

Player.cppに敵との当たり判定処理を追加します。

#include "Player.h"

#include "PlayerBullet.h" // 弾を生成して【使う処理があるのでインクルード必要】

// 更新処理
void Player::Update()
{
  // 継承したGameObjectにvがあるのでvをfloatで定義し直さないように注意
  v = Vector3(0,0,0); // xyz方向移動速度

  if (Input::GetButton(PAD_INPUT_LEFT))
  {
    v.x = -MoveSpeed; // 左
  }
  else if (Input::GetButton(PAD_INPUT_RIGHT))
  {
    v.x = MoveSpeed; // 右
  }
  if (Input::GetButton(PAD_INPUT_UP))
  {
    v.y = -MoveSpeed; // 上
  }
  else if (Input::GetButton(PAD_INPUT_DOWN))
  {
    v.y = MoveSpeed; // 下
  }

  // 斜め移動も同じ速度になるように調整
  if (v.magnitude() > 0)
  {
    v /= MyMath::Sqrt2;
  }

  // 実際に位置を動かす
  position += v;

  // ボタン押下で自機弾を発射
  if (Input::GetButtonDown(PAD_INPUT_1))
  {
    // C++ではAddがpush_backに↓ newがmake_shared↓に
    gm.playerBullets.emplace_back(std::make_shared<PlayerBullet>(position, 0));//右
    gm.playerBullets.emplace_back(std::make_shared<PlayerBullet>(position, -15 * MyMath::Deg2Rad));//右上
    gm.playerBullets.emplace_back(std::make_shared<PlayerBullet>(position, +15 * MyMath::Deg2Rad));//右下
  } }

// 描画処理
void Player::Draw()
{
  DrawRotaGraphF(position.x, position.y, 1, 0, Image::player, TRUE);
}

// 敵にぶつかった時の処理
void Player::OnCollisionEnemy(std::shared_ptr<GameObject> other)
{
  isDead = true;
}

Game.cppを改修します。自機が死んだとき消す処理と自機と敵の衝突判定を追加します。

#include "Game.h"
#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako1.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  (中略)..................
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  (中略)..................

  if (!gm.player->isDead) // 自機が死んでいなければ
    gm.player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】

  // 自機弾の更新処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }
  
  // 敵の更新処理
  for (const auto& b : gm.enemies)
  {
    b->Update();
  }
  
  // 自機弾と敵の衝突判定
  for(const auto& playerBullet : gm.playerBullets)
  {
    // 自機弾が死んでたらスキップする
    if (playerBullet->isDead)
      continue;

    for(const auto& enemy : gm.enemies)
    {
      // 敵が死んでたらスキップする
      if (enemy->isDead)
        continue;

      // 自機弾と敵が重なっているか？
      if (MyMath::CircleCircleIntersection(
        playerBullet->position, playerBullet->collisionRadius,
        enemy->position, enemy->collisionRadius))
      {
        // 重なっていたら、それぞれのぶつかったときの処理を呼び出す
        enemy->OnCollisionPlayerBullet(playerBullet);
        playerBullet->OnCollisionEnemy(enemy);

        // 衝突の結果、自機弾が死んだら、この弾のループはおしまい
        if (playerBullet->isDead)
          break;
      }
    }
  }
  
  // 自機と敵の衝突判定
  for(const auto& enemy : gm.enemies)
  {
    // 自機が死んでたらこれ以上判定しない
    if (gm.player->isDead)
      break;

    // 敵が死んでたらスキップ
    if (enemy->isDead)
      continue;

    // 円同士の衝突判定で調べる
    if (MyMath::CircleCircleIntersection(
      gm.player->position, gm.player->collisionRadius,
      enemy->position, enemy->collisionRadius))
    {
      gm.player->OnCollisionEnemy(enemy);
    }
  }
  
  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.playerBullets,
    [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除

  // 敵のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemies,
    [](std::shared_ptr<Enemy>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
};

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 0.9f, 0, Image::bossImage, TRUE);

  // 敵の描画処理
  for (const auto& e : gm.enemies)
  {
    e->Draw();
  }

  if (!gm.player->isDead) // 自機が死んでいなければ
    gm.player->Draw(); // プレイヤの描画【忘れるとプレイヤ表示されない】

  // 自機弾の描画処理
  // C#のforeach文と同じく全自機弾を更新できる
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Draw();
  }
};

自機のライフの作成

Player.hにライフと無敵時間を定義します。

#ifndef PLAYER_H_
#define PLAYER_H_

#include "DxLib.h"
#include "Input.h"
#include "Image.h"
#include "MyMath.h"

#include "GameObject.h"

#include "GameManager.h"

class Player : public GameObject
{ // 継承は↑: public ～にする。publicをつけ忘れるとGameObjectの変数がすべてprivateとして継承されちゃう
public:
  const float MoveSpeed = 6; // 移動速度
  int MutekiJikan = 120; // 無敵時間

  float collisionRadius = 32; // 当たり判定半径

  int life = 3; // ライフ
  int mutekiTimer = 0; // 残り無敵時間。0以下なら無敵じゃないってこと

  //【仲介者パターン】ゲーム内のもの同士はマネージャを通して一元化してやり取り
  GameManager& gm = GameManager::GetInstance(); //唯一のゲームマネージャへの参照(&)を得る

  // コンストラクタ
  // pos : 初期位置
  Player(Vector3 pos) : GameObject( pos ) //【忘れると】GameObjectの初期化処理が飛ばされて大混乱！
  {
  }

  virtual ~Player() {}; // 仮想デストラクタ ※無いと【削除された関数を参照しようとしてますエラー】が出るかも
  // 更新処理の関数定義
  void Update();

  // 描画処理の関数定義
  void Draw();

  // 敵にぶつかった時の処理
  void OnCollisionEnemy(std::shared_ptr<GameObject> other);

  // ダメージを受ける処理
  void TakeDamage();
};

#endif

Player.cppに敵との当たり判定処理を追加します。

#include "Player.h"

#include "PlayerBullet.h" // 弾を生成して【使う処理があるのでインクルード必要】

// 更新処理
void Player::Update()
{
  // 継承したGameObjectにvがあるのでvをfloatで定義し直さないように修正
  v = Vector3(0,0,0); // xyz方向移動速度

  if (Input::GetButton(PAD_INPUT_LEFT))
  {
    v.x = -MoveSpeed; // 左
  }
  else if (Input::GetButton(PAD_INPUT_RIGHT))
  {
    v.x = MoveSpeed; // 右
  }
  if (Input::GetButton(PAD_INPUT_UP))
  {
    v.y = -MoveSpeed; // 上
  }
  else if (Input::GetButton(PAD_INPUT_DOWN))
  {
    v.y = MoveSpeed; // 下
  }

  // 斜め移動も同じ速度になるように調整
  if (v.magnitude() > 0)
  {
    v /= MyMath::Sqrt2;
  }

  // 実際に位置を動かす
  position += v;

  // ボタン押下で自機弾を発射
  if (Input::GetButtonDown(PAD_INPUT_1))
  {
    // C++ではAddがpush_backに↓ newがmake_shared↓に
    gm.playerBullets.emplace_back(std::make_shared<PlayerBullet>(position, 0));//右
    gm.playerBullets.emplace_back(std::make_shared<PlayerBullet>(position, -15 * MyMath::Deg2Rad));//右上
    gm.playerBullets.emplace_back(std::make_shared<PlayerBullet>(position, +15 * MyMath::Deg2Rad));//右下
  }
  mutekiTimer--; // 無敵タイマーは無条件で毎フレームカウントダウン
}

// 描画処理
void Player::Draw()
{
  // 無敵ではない場合は描画
  // 無敵中は2フレームに1回描画（点滅）
  if (mutekiTimer <= 0 || mutekiTimer % 2 == 0)
    DrawRotaGraphF(position.x, position.y, 1, 0, Image::player, TRUE);
}

// 敵にぶつかった時の処理
void Player::OnCollisionEnemy(std::shared_ptr<GameObject> other)
{
  // 無敵じゃなければダメージを受ける
  if (mutekiTimer <= 0)
  {
    TakeDamage();
  }
}

// ダメージを受ける処理
void Player::TakeDamage()
{
  life -= 1; // ライフ減少

  if (life <= 0)
  {
    // ライフが無くなったら死亡
    isDead = true;
  }
  else
  {
    // 無敵時間発動
    mutekiTimer = MutekiJikan;
  }
}

敵弾の作成

敵弾の作成(発射間隔を空けて撃つ方法を学ぶ)

EnemyBullet.hを新規作成します。

#ifndef ENEMYBULLET_H_
#define ENEMYBULLET_H_

#include <cmath> //sin,cosを使うのに必要

#include "DxLib.h"
#include "Image.h"
#include "Screen.h"
#include "Vector3.h"

#include "GameObject.h"

// 敵弾クラス
class EnemyBullet: public GameObject
{
public:
  const int VisibleRadius = 8; // 見た目の半径
  

  float angle; // 移動角度(垂直Vertical)
  float angleH=0; // 移動角度(水平Horizontal)


  // コンストラクタ
  EnemyBullet(Vector3 pos, float angle, float speed) : GameObject( pos )
  {
    this->angle = angle;

    // 角度からx方向の移動速度を算出
    v.x = (float)std::cos(angle) * speed;
    // 角度からy方向の移動速度を算出
    v.y = (float)std::sin(angle) * speed;
  }

  // コンストラクタ
  EnemyBullet(Vector3 pos, float angleV, float angleH, float speed) : GameObject( pos )
  {
    this->angle = angleV;
    this->angleH = angleH;

    // [3Dの角度は水平・垂直に分割]https://teratail.com/questions/126004
    float cosAngleV = (float)std::cos(angle);
    // 角度からx方向の移動速度を算出
    v.x = cosAngleV * (float)std::sin(angleH) * speed;
    // 角度からy方向の移動速度を算出
    v.y = (float)std::sin(angle) * speed;
    // 角度からz方向の移動速度を算出
    v.z = cosAngleV * (float)std::cos(angleH) * speed;
  }

  // 更新処理
  void Update()
  {
    // 速度の分だけ移動
    position += v;

    // 画面外に出たら死亡フラグを立てる
    if (position.y + VisibleRadius < 0 || position.y - VisibleRadius > Screen::Height ||
      position.x + VisibleRadius < 0 || position.x - VisibleRadius > Screen::Width)
    {
      isDead = true;
    }
  }

  // 描画処理
  void Draw()
  {
    DrawRotaGraphF(position.x, position.y, 1, angle, Image::enemyBullet16,TRUE);
  }

  // プレイヤにぶつかった時の処理
  virtual void OnCollisionPlayer(std::shared_ptr<GameObject> other)
  {
    isDead = true;
  }
};

#endif

GameManager.hにEnemyBulletを管理するリストの定義を追加します。

#ifndef GAMEMANAGER_H_
#define GAMEMANAGER_H_

#include <memory>
#include <vector>

#include "Singleton.h"

class Player; // クラス宣言だけで★インクルードしないのでこのマネージャファイルで循環は止まる
class PlayerBullet;
class Enemy;
class EnemyBullet;

class GameManager : public Singleton<GameManager>//←<～>として継承すると唯一のシングルトン型タイプとなる
{
public:
  friend class Singleton<GameManager>; // Singleton でのインスタンス作成は許可

  std::shared_ptr<Player> player{ nullptr }; // 自機のポインタ
  std::list<std::shared_ptr<PlayerBullet>> playerBullets; // 自機弾のリスト
  std::list<std::shared_ptr<Enemy>> enemies; // 敵のリスト
  std::list<std::shared_ptr<EnemyBullet>> enemyBullets; // 敵弾のリスト
  // 複数リスト↑list ↑【shared_ptr】回し読みポインタ:メモリにデータを回し読み状態として確保できる


(中略)..............
protected:
  GameManager() {}; // 外部からのインスタンス作成は禁止
  virtual ~GameManager() {}; //外部からのインスタンス破棄も禁止
};

#endif

Game.cppにEnemyBulletの更新Updateと削除Remove、描画Drawの処理を追加します。

#include "Game.h"
#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "EnemyBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako1.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  (中略)..................
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  (中略)..................

  if (!gm.player->isDead) // 自機が死んでいなければ
    gm.player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】

  // 自機弾の更新処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }

  // 敵弾の更新処理
  for (const auto& b : gm.enemyBullets)
  {
    b->Update();
  }

  // 敵の更新処理
  for (const auto& b : gm.enemies)
  {
    b->Update();
  }
  
  // 自機弾と敵の衝突判定
  for(const auto& playerBullet : gm.playerBullets)
  {
    // 自機弾が死んでたらスキップする
    if (playerBullet->isDead)
      continue;

    for(const auto& enemy : gm.enemies)
    {
      // 敵が死んでたらスキップする
      if (enemy->isDead)
        continue;

      // 自機弾と敵が重なっているか？
      if (MyMath::CircleCircleIntersection(
        playerBullet->position, playerBullet->collisionRadius,
        enemy->position, enemy->collisionRadius))
      {
        // 重なっていたら、それぞれのぶつかったときの処理を呼び出す
        enemy->OnCollisionPlayerBullet(playerBullet);
        playerBullet->OnCollisionEnemy(enemy);

        // 衝突の結果、自機弾が死んだら、この弾のループはおしまい
        if (playerBullet->isDead)
          break;
      }
    }
  }
  
  // 自機と敵の衝突判定
  for(const auto& enemy : gm.enemies)
  {
    // 自機が死んでたらこれ以上判定しない
    if (gm.player->isDead)
      continue;

    // 敵が死んでたらスキップ
    if (enemy->isDead)
      continue;

    // 円同士の衝突判定で調べる
    if (MyMath::CircleCircleIntersection(
      gm.player->position, gm.player->collisionRadius,
      enemy->position, enemy->collisionRadius))
    {
      gm.player->OnCollisionEnemy(enemy);
    }
  }
  
  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.playerBullets,
    [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  // 敵のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemies,
    [](std::shared_ptr<Enemy>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  // 敵弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemyBullets,
    [](std::shared_ptr<EnemyBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
};

void Game::Draw()
{// 描画処理
  DrawRotaGraphF(x, 200, 0.9f, 0, Image::bossImage, TRUE);

  // 敵の描画処理
  for (const auto& e : gm.enemies)
  {
    e->Draw();
  }

  if (!gm.player->isDead) // 自機が死んでいなければ
    gm.player->Draw(); // プレイヤの描画【忘れるとプレイヤ表示されない】

  // 自機弾の描画処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Draw();
  }

  // 敵弾の描画処理
  for (const auto& b : gm.enemyBullets)
  {
    b->Draw();
  }
};

Zako0.hに弾を発射間隔を開けながら撃たせます。

#ifndef ZAKO_0_H_
#define ZAKO_0_H_

#include "Enemy.h"
#include "Image.h"
#include "MyMath.h"
#include "EnemyBullet.h" // make_sharedなど【実際の弾を撃ち生成処理を行うのでインクルード必要】

// ザコ0クラス
class Zako0 : public Enemy
{
public:
  int counter = 0;

  // コンストラクタ
  Zako0(Vector3 pos) : Enemy( pos )
  {
    this->tag = "Zako0";
  }

  // 更新処理
  void Update() override
  {
    position.x -= 1; // とりあえず左へ移動

    counter++;

    if (counter % 10 == 0)
    {
      gm.enemyBullets.emplace_back(std::make_shared<EnemyBullet>(position, 180 * MyMath::Deg2Rad, 8));
    }
  }

  // 描画処理
  void Draw() override
  {
    DrawRotaGraphF(position.x, position.y, 1, 0, Image::zako0, TRUE);
  }
};

#endif

Zako0.hの弾の発射間隔を開ける方法は別のやり方もあります。

#ifndef ZAKO_0_H_
#define ZAKO_0_H_

#include "Enemy.h"
#include "Image.h"
#include "MyMath.h"
#include "EnemyBullet.h" // make_sharedなど【実際の弾を撃ち生成処理を行うのでインクルード必要】

// ザコ0クラス
class Zako0 : public Enemy
{
public:
  int coolTime = 0; // クールタイム（冷却時間。0になるまで次の弾が撃てない）

  // コンストラクタ
  Zako0(Vector3 pos) : Enemy( pos )
  {
    this->tag = "Zako0";
  }

  // 更新処理
  void Update() override
  {
    position.x -= 1; // とりあえず左へ移動

    coolTime--;

    if (coolTime <= 0)
    {
      gm.enemyBullets.emplace_back(std::make_shared<EnemyBullet>(position, 180 * MyMath::Deg2Rad, 8));
      coolTime += 10;
    }
  }

  // 描画処理
  void Draw() override
  {
    DrawRotaGraphF(position.x, position.y, 1, 0, Image::zako0, TRUE);
  }
};

#endif

練習問題(色んな弾の撃ち方を試す)

弾の発射角度の方向を180度 + (-15度～+15度)にすることで散乱弾を実現します。

まず、乱数生成に必要な乱数クラスMyRandom.hを作成します。

#ifndef MYRANDOM_H_
#define MYRANDOM_H_

#include <random>

class MyRandom
{
public:
  // ゲーム中で唯一のインスタンス
  static std::random_device rnd;// 非決定的な乱数生成器
  static std::mt19937 random; // メルセンヌ・ツイスタの32ビット版

  // 初期化（シード指定無し）
  static void Init()
  { // https://cpprefjp.github.io/reference/random/random_device.html
    random.seed(rnd()); // 乱数をシードにすることで毎回ランダムにする
  }

  // 初期化（シードを指定）
  static void Init(int seed)
  {
    random.seed(seed);
  }

  // 指定した範囲の整数の乱数を取得する
  static int Range(int min, int max)
  {
    std::uniform_int_distribution<> randRange(min, max); // [min, max] 範囲の一様乱数
    return randRange(random);
  }

  // 指定した範囲の小数の乱数を取得する
  static float Range(float min, float max)
  {
    std::uniform_real_distribution<> randRange(min, max); // [min<= x <=max] 範囲の一様乱数
    return (float)randRange(random);
  }

  // 指定した確率（％）でtrueになる
  static bool Percent(float probability)
  {
    return Range(0.0f, 1.0f) * 100 <= probability;
  }

  // 指定した範囲で乱数を返却する。
  // 例えば1.5fを指定すると、-1.5～+1.5の範囲の値を返却する。
  static float PlusMinus(float value)
  {
    return Range(-value, value);
  }
};

#endif

staticなクラスなのでMyRandom.cppを作成して変数をcppで定義初期化します。

#include "MyRandom.h"

std::random_device MyRandom::rnd;// 非決定的な乱数生成器
std::mt19937 MyRandom::random; // メルセンヌ・ツイスタの32ビット版 https://qiita.com/angel_p_57/items/971d0208186f81d5d044

Zako2.hを作成して弾の発射方向を-15度～+15度までランダムに散らすようにしてみます。

#ifndef ZAKO_2_H_
#define ZAKO_2_H_

#include "Enemy.h"
#include "Image.h"
#include "Screen.h"
#include <cmath> // Sin Cosの計算に使う
#include "MyMath.h"
#include "MyRandom.h"
#include "EnemyBullet.h" // make_sharedなど【実際の弾を撃ち生成処理を行うのでインクルード必要】

// ザコ2クラス
class Zako2 : public Enemy
{
public:
  int coolTime = 0; // クールタイム（冷却時間。0になるまで次の弾が撃てない）

  // コンストラクタ
  Zako2(Vector3 pos) : Enemy( pos )
  {
    this->tag = "Zako2";
  }

  // 更新処理
  void Update() override
  {
    if(position.x > Screen::Width - 200)
    { // スクリーンの端から200の位置で止まる
      position.x -= 1; // とりあえず左へ移動
    }

    coolTime--;

    if (coolTime <= 0)
    {
      float bulletAngle = MyRandom::Range(-15.0f,15.0f); // ±15度の乱数の角度を取得
      gm.enemyBullets.emplace_back(std::make_shared<EnemyBullet>(position, (180 + bulletAngle) * MyMath::Deg2Rad, 8));
      coolTime += 10;
    }
  }

  // 描画処理
  void Draw() override
  {
    DrawRotaGraphF(position.x, position.y, 1, 0, Image::zako2, TRUE);
  }
};

#endif

Game.cppにMyRandom乱数とザコ2の初期化を追加します。

#include "Game.h"
#include "MyRandom.h" 
#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "EnemyBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako1.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako2.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理
  Image::Load(); //画像の読込み
  MyRandom::Init(); // 乱数シードの初期化

  (中略)..................

  // とりあえず適当に敵を生成
  gm.enemies.emplace_back(std::make_shared<Zako0>(Vector3((float)600, (float)100)));
  gm.enemies.emplace_back(std::make_shared<Zako0>(Vector3((float)1000, (float)500)));
  gm.enemies.emplace_back(std::make_shared<Zako1>(Vector3((float)1000, (float)150)));
  gm.enemies.emplace_back(std::make_shared<Zako2>(Vector3((float)1200, (float)250)));
};

void Game::Update()
{// 更新処理

  (中略)..................

};

void Game::Draw()
{// 描画処理

  (中略)..................
};

どうでしょうか(-15度～+15度)の散乱弾を撃つ敵キャラを作れましたか？

まずはザコ2を試してみましょう。うまくいったら次のザコ3を試してみましょう。

こんどはZako3.hを作成して10ダメージ受けると点滅状態(5秒=5×60=300フレーム)になり、isDeadと同時に弾を全方向に0度～360度に散らすようにしてみます。

勉強になるテクニックとして【共通処理の上書きオーバーライド】や【点滅処理の条件式】や【ド・モルガンの定理】を使っているので上級者も1度は試してみましょう。

#ifndef ZAKO_3_H_
#define ZAKO_3_H_

#include "Enemy.h"
#include "Image.h"
#include "Screen.h"
#include <cmath> // Sin Cosの計算に使う
#include "MyMath.h"
#include "Vector3.h"
#include "MyRandom.h"
#include "EnemyBullet.h" // make_sharedなど【実際の弾を撃ち生成処理を行うのでインクルード必要】

// ザコ3クラス(自爆型機雷タイプの敵キャラ)
class Zako3 : public Enemy
{
public:
  int bombCounter = -1; // やられたときのisDeadまでのカウントダウン
  int BombTime = 300; // 爆発までのカウント時間
  int life = 10; // 敵ライフ

  // コンストラクタ
  Zako3(Vector3 pos) : Enemy( pos )
  {
    this->tag = "Zako3";
  }

  // 更新処理
  void Update() override
  {
    if(position.x > Screen::Width - 350)
    { // スクリーンの端から350の位置で止まる
      position.x -= 1; // とりあえず左へ移動
    }
    else
    { // スクリーン端から350の位置で自爆モードに入る
      life = 0; // 画面中央付近で勝手にlife=0で自爆モードに入る
    }

    bombCounter--; // 爆発カウンタは常にカウントダウン(-1から始まるときは0を通過しないので爆発しない)

    if(life <= 0 && bombCounter < 0)
      bombCounter = BombTime; // 爆発モードに入る(bombCounterがプラス値になり0になると爆発)

    if (bombCounter == 0) // 初期状態は-1からカウントダウン-1,-2,-3..するからここには入らずに済む
    {
      for(int i=0; i < 360; i = i+10) //【勉強】for文は1ずつプラスじゃなくてもよい
      {
        gm.enemyBullets.emplace_back(std::make_shared<EnemyBullet>(position, (180 + i) * MyMath::Deg2Rad, 6));
      }
      isDead = true; // 爆発カウンタ==0で初めてisDead状態に
    }
  }

  // 【勉強】共通処理を上書きオーバーライドで上塗りして共通処理を無効化・乗っ取るテクニック
  // 自機弾との衝突処理を★【上書きオーバーライド】して死亡フラグが立たないように
  virtual void OnCollisionPlayerBullet(std::shared_ptr<GameObject> playerBullet) override
  {
    life -= 1; // ライフを減らす

    // 死亡フラグはこのザコ3だけ特別に衝突ではONにしない
  }

  // 描画処理
  void Draw() override
  {  
    //【ド・モルガンの定理を学ぼう】||と&&の逆の関係性の法則
    //【勉強】条件【または||】は条件【かつ&&】の(life <= 0 && bombCounter > 0)のちょうど逆条件！
    if(life > 0 || bombCounter <= 0
     || (bombCounter % 8 < 4) ) //[点滅]パラパラ8枚の周期で余り4以下の時だけ描く
      DrawRotaGraphF(position.x, position.y, 1, 0, Image::zako3, TRUE);
  }
};

#endif

Game.cppにザコ3の生成処理を追加します。

#include "Game.h"
#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "EnemyBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako1.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako2.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako3.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  (中略)..................

  // とりあえず適当に敵を生成
  gm.enemies.emplace_back(std::make_shared<Zako0>(Vector3((float)600, (float)100)));
  gm.enemies.emplace_back(std::make_shared<Zako0>(Vector3((float)1000, (float)500)));
  gm.enemies.emplace_back(std::make_shared<Zako1>(Vector3((float)1000, (float)150)));
  gm.enemies.emplace_back(std::make_shared<Zako2>(Vector3((float)1200, (float)250)));
  gm.enemies.emplace_back(std::make_shared<Zako3>(Vector3((float)1300, (float)400)));
};

void Game::Update()
{// 更新処理

  (中略)..................

};

void Game::Draw()
{// 描画処理

  (中略)..................
};

どうでしょうか爆弾っぽい自爆タイプの敵キャラが作れましたか？

[C++]シューティングゲーム 3

1. 自機と敵弾の当たり判定
2. 爆発エフェクトの作成(分割画像DivImage型の定義)
   爆発クラスの作成
   管理する仕組みの作成
   爆発を出す処理(Enemyで敵の共通の爆発を生成)
   
3. ボスの作成
4. 【練習問題】ボスの状態ごとの行動パターンのプログラミング
5. プレイヤのライフをバーで表示させる
6. アイテムクラスとザコからのドロップ処理の作成
7. Item0を画面のはしっこで光らせてバウンドさせる処理の作成
8. Item1クラスでボスへクリティカルヒットしたらバリアーとなる星のアイテムをドロップする処理の作成



次のテキスト4はこちら。


[C++]シューティングゲーム 4

自機と敵弾の当たり判定

自機と敵弾がぶつかったら、自機がダメージを受けるようにしましょう。

EnemyBullet.hに当たり判定の大きさを表す変数を追加します。

#ifndef ENEMYBULLET_H_
#define ENEMYBULLET_H_

#include <cmath> //sin,cosを使うのに必要

#include "DxLib.h"
#include "Image.h"
#include "Screen.h"

#include "GameObject.h"

// 敵弾クラス
class EnemyBullet: public GameObject
{
public:
  const int VisibleRadius = 8; // 見た目の半径
  float collisionRadius = 8; // 当たり判定半径

  (以下略)........................

Player.hに敵弾とぶつかったときの処理の定義を追加します。

#ifndef PLAYER_H_
#define PLAYER_H_

#include "DxLib.h"
#include "Input.h"
#include "Image.h"
#include "MyMath.h"

#include "GameObject.h"

#include "GameManager.h"

class Player : public GameObject
{ // 継承は↑: public ～にする。publicをつけ忘れるとGameObjectの変数がすべてprivateとして継承されちゃう
public:

  (中略)...........

  // 敵にぶつかった時の処理
  void OnCollisionEnemy(std::shared_ptr<GameObject> other);

  // 敵弾とぶつかった時の処理
  void OnCollisionEnemyBullet(std::shared_ptr<GameObject> other);

  // ダメージを受ける処理
  void TakeDamage();
};

#endif

Player.cppに敵弾とぶつかったときの処理を追加します。

#include "Player.h"

#include "PlayerBullet.h" // 弾を生成して【使う処理があるのでインクルード必要】

// 更新処理
void Player::Update()
{
  (中略).........
}

// 描画処理
void Player::Draw()
{
  (中略).........
}

// 敵にぶつかった時の処理
void Player::OnCollisionEnemy(std::shared_ptr<GameObject> other)
{
  // 無敵じゃなければダメージを受ける
  if (mutekiTimer <= 0)
  {
    TakeDamage();
  }
}

// 敵弾とぶつかった時の処理
void Player::OnCollisionEnemyBullet(std::shared_ptr<GameObject> other)
{
  // 無敵じゃなければダメージを受ける
  if (mutekiTimer <= 0)
  {
    TakeDamage();
  }
}

// ダメージを受ける処理
void Player::TakeDamage()
{
  life -= 1; // ライフ減少

  if (life <= 0)
  {
    // ライフが無くなったら死亡
    isDead = true;
  }
  else
  {
    // 無敵時間発動
    mutekiTimer = MutekiJikan;
  }
}

Game.cppに当たり判定の処理を追加します。

#include "Game.h"
#include "MyRandom.h"
#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "EnemyBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako1.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako2.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako3.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  (中略)..................
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  (中略)..................

  if (!gm.player->isDead) // 自機が死んでいなければ
    gm.player->Update(); // プレイヤの更新【忘れるとプレイヤが動かない】

  // 自機弾の更新処理
  // for文で全自機弾をループで回してUpdateで更新する
  for (const auto& b : gm.playerBullets)
  {  // autoキーワードはビルドのコンパイル機械語翻訳の時に型を自動推論してくれる
    b->Update();
  }
  
  // 敵弾の更新処理
  for (const auto& b : gm.enemyBullets)
  {
    b->Update();
  }
  
  // 自機と敵弾の衝突判定
  for (const auto& enemyBullet : gm.enemyBullets)
  {
    // 自機が死んでたらこれ以上判定しない
    if (gm.player->isDead)
      break;

    // 敵弾が死んでたらスキップ
    if (enemyBullet->isDead)
      continue;

    // 円同士の衝突判定で調べる
    if (MyMath::CircleCircleIntersection(
      gm.player->position, gm.player->collisionRadius,
      enemyBullet->position, enemyBullet->collisionRadius))
    {
      gm.player->OnCollisionEnemyBullet(enemyBullet);
    }
  }

  // 敵の更新処理
  for (const auto& e : gm.enemies)
  {
    e->Update();
  }
  
  // 自機弾と敵の衝突判定
  for(const auto& playerBullet : gm.playerBullets)
  {
    // 自機弾が死んでたらスキップする
    if (playerBullet->isDead)
      continue;

    for(const auto& enemy : gm.enemies)
    {
      // 敵が死んでたらスキップする
      if (enemy->isDead)
        continue;

      // 自機弾と敵が重なっているか？
      if (MyMath::CircleCircleIntersection(
        playerBullet->position, playerBullet->collisionRadius,
        enemy->position, enemy->collisionRadius))
      {
        // 重なっていたら、それぞれのぶつかったときの処理を呼び出す
        enemy->OnCollisionPlayerBullet(playerBullet);
        playerBullet->OnCollisionEnemy(enemy);

        // 衝突の結果、自機弾が死んだら、この弾のループはおしまい
        if (playerBullet->isDead)
          break;
      }
    }
  }
  
  // 自機と敵の衝突判定
  for(const auto& enemy : gm.enemies)
  {
    // 自機が死んでたらこれ以上判定しない
    if (gm.player->isDead)
      continue;

    // 敵が死んでたらスキップ
    if (enemy->isDead)
      continue;

    // 円同士の衝突判定で調べる
    if (MyMath::CircleCircleIntersection(
      gm.player->position, gm.player->collisionRadius,
      enemy->position, enemy->collisionRadius))
    {
      gm.player->OnCollisionEnemy(enemy);
    }
  }
  
  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.playerBullets,
    [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除

  // 敵のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemies,
    [](std::shared_ptr<Enemy>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
};

void Game::Draw()
{// 描画処理
  (中略)......
};

爆発エフェクトの作成(分割画像DivImage型の定義)

分割画像DivImage型でデータ内部に分割画像の分割XY数や画像サイズ、画像数も覚えておく

DivImage.hを新規作成して、カスタムしたデータタイプ【DivImage型】を定義して縦2×横8の分割された爆発画像を読込みましょう。

#ifndef DIVIMAGE_H_
#define DIVIMAGE_H_

#include "DxLib.h"
#include <assert.h> // 画像の2のべき乗チェックに使う

// 分割画像を読込むためのデータ構造(画像数や画像ハンドル配列、3Dに使う場合の2のべき乗チェック機能をもつ)
class DivImage
{  // 2Dの分割画像や3Dに分割Div画像を使うと画像全体が使われてしまうのを回避するための情報
public:
  int XNum = 0;
  int YNum = 0;
  int XSize = 0;
  int YSize = 0;
  int* HandleArray = nullptr;
  int AllNum = 0;
  bool is3DTexture = false;

// 初期化 : X方向分割画像数 XNum, Y方向分割画像数 YNum, 画像 横 幅XSizeピクセル, 画像 縦 高さYSizeピクセル
  DivImage(int XNum, int YNum, int XSize, int YSize, bool is3DTexture=false)
  { // 初期化コンストラクタ
    this->XNum = XNum; // X方向分割画像数
    this->YNum = YNum; // Y方向分割画像数
    this->XSize = XSize; // 画像 横 幅XSize(ピクセルドット数)
    this->YSize = YSize; // 画像 縦 高さYSize(ピクセルドット数)
    AllNum = XNum * YNum; // トータルの分割画像数
    this->is3DTexture = is3DTexture; // 3Dテクスチャ分割画像かtrueだと2のべき乗チェックが入る
    // ★div分割画像読込ハンドラ保存用のint配列メモリを確保し-1で初期化
    this->HandleArray = new int[AllNum]; // 配列を確保し-1で初期化
    for (int i = 0; i < AllNum; i++) HandleArray[i] = -1;
    //↑【演習★】初期化後の動的配列をデバッガで見てみよう[ary,256として再評価ボタン]
    // http://visualstudiostudy.blog.fc2.com/blog-entry-17.html
    int* ary = HandleArray;
#ifdef _DEBUG // デバッグ機能(デバッグの時だけ _DEBUG が定義)
    if(is3DTexture==true) ImagePowCheck((*this)); // *(this)でthisポインタの示す変数内容を表す
#endif
  };

  ~DivImage()
  { // デストラクタでメモリを解放
    if (this->HandleArray != nullptr)
      delete[] this->HandleArray;
  };

  //【勉強 []添え字演算子を独自に定義】https://programming.pc-note.net/cpp/operator.html
  // 内部のHandleArrayへ今までの様にImage::explosion[5]とかで簡単アクセスできるように【あいだに噛ます】
  int const& operator [](int index) const
  {
    if(index<0 || AllNum<=index) assert("画像データのアクセス番号がおかしい！" == "");
    return HandleArray[index];
  }
  int& operator [](int index)
  {
    if(index<0 || AllNum<=index) assert("画像データのアクセス番号がおかしい！" == "");
    return HandleArray[index];
  }

#ifdef _DEBUG // デバッグ機能(デバッグの時だけ _DEBUG が定義)
  bool is_pow2(unsigned int x) // 2のべき乗か計算
  { // https://programming-place.net/ppp/contents/c/rev_res/math012.html
    return (x != 0) && (x & (x - 1)) == 0;
  }

  void ImagePowCheck(DivImage& divImage)
  { // ★3Dに使う画像は2のべき乗でなければ受け付けないようにする
    // https://yttm-work.jp/gmpg/gmpg_0031.html
    // https://yappy-t.hatenadiary.org/entry/20100110/1263138881
    if (divImage.XSize > 0 && divImage.YSize > 0
      && is_pow2(divImage.XSize) && is_pow2(divImage.YSize)) return;
    else assert("3Dに使うなら2のべき乗の画像サイズにしなきゃ" == "");
  }
#endif

private: // コピーと代入をプライベートにして禁止する
    // コピーコンストラクタの禁止privateオーバーロード
    DivImage(const DivImage& divImage) {};

    // 代入演算子の禁止privateオーバーロード
    void operator=(const DivImage& divImage) {};
};

#endif

Image.hでカスタムしたデータタイプ【DivImage型】で縦2×横8の分割された爆発画像を読込みましょう。

#ifndef IMAGE_H_
#define IMAGE_H_

#include "DxLib.h"
#include <assert.h> // 画像読み込みの読込み失敗表示用
#include "DivImage.h" // 分割画像の読込みに使う

class Image
{
public:
  Image() {}; // 初期化コンストラクタ:定義と{}空の処理
  ~Image() {}; // 破棄する処理デストラクタ:定義と{}空の処理
  static void Load();
  static int LoadDivGraph(const TCHAR* FileName, DivImage& divImage);

  static int bossImage; //ボス画像のハンドラ(読込画像番号)
  static int player; //プレイヤ画像のハンドラ
  static int playerBullet; //プレイヤの弾画像のハンドラ
  static int enemyBullet16; //敵弾 画像のハンドラ(読込画像番号)
  static int zako0; //ザコ0 画像のハンドラ(読込画像番号)
  static int zako1; //ザコ1 画像のハンドラ(読込画像番号)
  static int zako2; //ザコ2 画像のハンドラ(読込画像番号)
  static int zako3; //ザコ3 画像のハンドラ(読込画像番号)
  static DivImage explosion; // [分割画像]爆発エフェクト

private:

};
#endif

次に対となるcppファイルも変更します。
Image.cppの内容を次のようにします：

#include "Image.h"

int Image::bossImage{-1}; // Load終わっても-1(初期値)のままだと画像ロードが失敗してますね
int Image::player{-1};
int Image::playerBullet{-1};
int Image::enemyBullet16{-1};
int Image::zako0{-1};
int Image::zako1{-1};
int Image::zako2{-1};
int Image::zako3{-1};
// ★分割画像は初期化のときに{X方向画像数, Y方向画像数, 画像横幅XSize,画像縦幅YSize}を指定
DivImage Image::explosion{ 8, 2, 64, 64 };
//↑どのような画像を使うかで変わる
// 例えば https://pipoya.net/sozai/assets/effects/effect-event-1/ のイベントエフェクト.zipの
// 1800×180の縦一列のみなら DivImage Image::explosion{ 10, 1, 180, 180 };となる

void Image::Load()
{
  bossImage = LoadGraph("Image/boss1.png");
  assert(bossImage != -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  player= LoadGraph("Image/player.png");
  assert(player!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  playerBullet = LoadGraph("Image/player_bullet.png");
  assert(playerBullet!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  enemyBullet16 = LoadGraph("Image/enemy_bullet_16.png");
  assert(enemyBullet16!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako0 = LoadGraph("Image/zako0.png");
  assert(zako0!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako1 = LoadGraph("Image/zako1.png");
  assert(zako1!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako2 = LoadGraph("Image/zako2.png");
  assert(zako2!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako3 = LoadGraph("Image/zako3.png");
  assert(zako3!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  // div分割画像をロード
  Image::LoadDivGraph("Image/explosion.png", explosion);
  for (int i = 0; i < explosion.AllNum; i++)
  { // 画像読込失敗
    if (explosion.HandleArray[i] == -1) assert("爆発分割画像読込失敗" == "");
  }
}

// DXライブラリのLoadDivGraphを使いやすくラッピング
// ★関数に参照渡しを行う
// 関数の引数に参照渡しを行うことでdivImageの中身を書き換えることができる(値渡しでは書換不可)
//　https://qiita.com/agate-pris/items/05948b7d33f3e88b8967
// https://qiita.com/RuthTaro/items/f35c3a26779c0ca1a41a
int Image::LoadDivGraph(const TCHAR* FileName, DivImage& divImage)
{
  return DxLib::LoadDivGraph(FileName, divImage.XNum * divImage.YNum,
    divImage.XNum, divImage.YNum, divImage.XSize, divImage.YSize, divImage.HandleArray);
};

爆発クラスの作成

Explosion.hを新規作成して爆発エフェクトを表示するクラスを作ります。

#ifndef EXPLOSION_H_
#define EXPLOSION_H_

#include "Image.h"

#include "GameObject.h"

// 爆発エフェクトクラス
class Explosion : public GameObject
{
public:
  int counter = 0; // 時間を計るための変数
  int imageIndex = 0; // 表示すべき画像の番号

  // コンストラクタ
  Explosion(Vector3 pos) : GameObject( pos )
  {
    this->tag = "Explosion";
  }

  // 更新処理
  void Update() override
  {
    counter++;

    imageIndex = counter / 3; // そのままだと速すぎるので、3で割る

    // 絵は16枚しかない（0～15）ので、
    // 16番目を表示しようとしたら終了。
    if (imageIndex >= 16)
    {
      isDead = true;
    }
  }

  // 描画処理
  void Draw() override
  {
  // 分割して読み込んだ絵のハンドルが各要素に格納されているので、
  // 要素番号を指定してハンドルを取り出して使う。
    DrawRotaGraphF(position.x, position.y, 1, 0, Image::explosion[imageIndex], TRUE);
  }
};

#endif

管理する仕組みの作成

GameManager.hにExplosionを管理するリストの定義を追加します。

#ifndef GAMEMANAGER_H_
#define GAMEMANAGER_H_

#include <memory>
#include <vector>

#include "Singleton.h"

class Player; // クラス宣言だけで★インクルードしないのでこのマネージャファイルで循環は止まる
class PlayerBullet;
class Enemy;
class EnemyBullet;
class Explosion;

class GameManager : public Singleton<GameManager>//←<～>として継承すると唯一のシングルトン型タイプとなる
{
public:
  friend class Singleton<GameManager>; // Singleton でのインスタンス作成は許可

  std::shared_ptr<Player> player{ nullptr }; // 自機のポインタ
  std::list<std::shared_ptr<PlayerBullet>> playerBullets; // 自機弾のリスト
  std::list<std::shared_ptr<Enemy>> enemies; // 敵のリスト
  std::list<std::shared_ptr<EnemyBullet>> enemyBullets; // 敵弾のリスト
  std::list<std::shared_ptr<Explosion>> explosions; // 爆発エフェクトのリスト
  // 複数リスト↑list ↑【shared_ptr】回し読みポインタ:メモリにデータを回し読み状態として確保できる


(中略)..............
protected:
  GameManager() {}; // 外部からのインスタンス作成は禁止
  virtual ~GameManager() {}; //外部からのインスタンス破棄も禁止
};

#endif

Game.cppに当たり判定の処理を追加します。

#include "Game.h"

#include "MyRandom.h"

#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "EnemyBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Explosion.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako1.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako2.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako3.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  (中略)..................
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  (中略)..................

  // 自機と敵の衝突判定
  for(const auto& enemy : gm.enemies)
  {
    // 自機が死んでたらこれ以上判定しない
    if (gm.player->isDead)
      continue;

    // 敵が死んでたらスキップ
    if (enemy->isDead)
      continue;

    // 円同士の衝突判定で調べる
    if (MyMath::CircleCircleIntersection(
      gm.player->position, gm.player->collisionRadius,
      enemy->position, enemy->collisionRadius))
    {
      gm.player->OnCollisionEnemy(enemy);
    }
  }
  
  // 爆発エフェクトの更新処理
  for (const auto& e : gm.explosions)
  {
    e->Update();
  }
  

  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.playerBullets,
    [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  // 敵のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemies,
    [](std::shared_ptr<Enemy>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  // 敵弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemyBullets,
    [](std::shared_ptr<EnemyBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  //爆発エフェクトのリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.explosions,
    [](std::shared_ptr<Explosion>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
};

void Game::Draw()
{// 描画処理
  (中略)......

  // 敵の描画処理
  for (const auto& e : gm.enemies)
  {
    e->Draw();
  }
  
  // 爆発エフェクトの描画処理
  for (const auto& e : gm.explosions)
  {
    e->Draw();
  }
  
  (中略)......

};

爆発を出す処理(Enemyで敵の共通の爆発を生成)

Enemy.hを改修して、敵が死んだときに爆発エフェクトを出すようにしましょう。

#ifndef ENEMY_H_
#define ENEMY_H_

#include "GameObject.h"

#include "GameManager.h"

#include "Explosion.h"

// 敵の基底クラス。
// 全ての敵は、このクラスを継承して作る。
// ★【勉強】abstract型はC++にない!!【純粋仮想関数】を使って作る
class Enemy : public GameObject
{
public:

  //【仲介者パターン】ゲーム内のもの同士はマネージャを通して一元化してやり取り
  GameManager& gm = GameManager::GetInstance(); //唯一のゲームマネージャへの参照(&)を得る

  float collisionRadius = 32; // 当たり判定の半径
  bool isDead = false; // 死亡フラグ
  float life = 1; // 耐久力

  // コンストラクタ
  Enemy(Vector3 pos) : GameObject( pos ) // GameObjectをベースとして初期化処理を継承する
  {
    this->typeTag = "Enemy";
  }

  // 更新処理。派生クラスでオーバーライドして使う
  virtual void Update() = 0;//virtual ～ = 0;で【純粋仮想関数に】これで【C#のabstract型に】

  // 描画処理。派生クラスでオーバーライドして使う
  virtual void Draw() = 0; //virtual ～ = 0;で【純粋仮想関数に】【関数 = 0で未定義状態を表現】


  // 自機弾に当たったときの処理
  virtual void OnCollisionPlayerBullet(std::shared_ptr<GameObject> playerBullet)
  {
    life -= 1; // ライフを減らす

    // ライフが無くなったら、死亡
    if (life <= 0)
    {
      isDead = true;
      // 爆発を出す
      gm.explosions.emplace_back(std::make_shared<Explosion>(Vector3(position.x, position.y)));
    }
  }
};

#endif

ボスの作成

まずはボスの3状態の画像をImageフォルダに用意しておきましょう。

• boss1.png
• boss2.png
• boss3.png

Image.hにboss1.png、boss2.png、boss3.pngの読込み処理を追加します。

#ifndef IMAGE_H_
#define IMAGE_H_

#include "DxLib.h"
#include <assert.h> // 画像読み込みの読込み失敗表示用
#include "DivImage.h" // 分割画像の読込みに使う

class Image
{
public:
  Image() {}; // 初期化コンストラクタ:定義と{}空の処理
  ~Image() {}; // 破棄する処理デストラクタ:定義と{}空の処理
  static void Load();
  static int LoadDivGraph(const TCHAR* FileName, DivImage& divImage);

  static int bossImage; //ボス画像のハンドラ(読込画像番号)
  static int player; //プレイヤ画像のハンドラ
  static int playerBullet; //プレイヤの弾画像のハンドラ
  static int enemyBullet16; //敵弾 画像のハンドラ(読込画像番号)
  static int zako0; //ザコ0 画像のハンドラ(読込画像番号)
  static int zako1; //ザコ1 画像のハンドラ(読込画像番号)
  static int zako2; //ザコ2 画像のハンドラ(読込画像番号)
  static int zako3; //ザコ3 画像のハンドラ(読込画像番号)
  static int boss1; //ボス通常 画像のハンドラ(読込画像番号)
  static int boss2; //ボス2気絶 画像のハンドラ(読込画像番号)
  static int boss3; //ボス3発狂 画像のハンドラ(読込画像番号)
  static DivImage explosion; // [分割画像]爆発エフェクト

private:

};
#endif

次に対となるcppファイルも変更します。
Image.cppの内容を次のようにします：

#include "Image.h"

int Image::bossImage{-1}; // Load終わっても-1(初期値)のままだと画像ロードが失敗してますね
int Image::player{-1};
int Image::playerBullet{-1};
int Image::enemyBullet16{-1};
int Image::zako0{-1};
int Image::zako1{-1};
int Image::zako2{-1};
int Image::zako3{-1};
int Image::boss1{-1};
int Image::boss2{-1};
int Image::boss3{-1};
// ★分割画像は初期化のときに{X方向画像数, Y方向画像数, 画像横幅XSize,画像縦幅YSize}を指定
DivImage Image::explosion{ 8, 2, 64, 64 };

void Image::Load()
{
  bossImage = LoadGraph("Image/boss1.png");
  assert(bossImage != -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  player= LoadGraph("Image/player.png");
  assert(player!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  playerBullet = LoadGraph("Image/player_bullet.png");
  assert(playerBullet!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  enemyBullet16 = LoadGraph("Image/enemy_bullet_16.png");
  assert(enemyBullet16!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako0 = LoadGraph("Image/zako0.png");
  assert(zako0!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako1 = LoadGraph("Image/zako1.png");
  assert(zako1!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako2 = LoadGraph("Image/zako2.png");
  assert(zako2!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako3 = LoadGraph("Image/zako3.png");
  assert(zako3!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  boss1 = LoadGraph("Image/boss1.png");
  assert(boss1!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  boss2 = LoadGraph("Image/boss2.png");
  assert(boss2!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  boss3 = LoadGraph("Image/boss3.png");
  assert(boss3!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  // div分割画像をロード
  Image::LoadDivGraph("Image/explosion.png", explosion);
  for (int i = 0; i < explosion.AllNum; i++)
  { // 画像読込失敗
    if (explosion.HandleArray[i] == -1) assert("爆発分割画像読込失敗" == "");
  }
}

// DXライブラリのLoadDivGraphを使いやすくラッピング
// ★関数に参照渡しを行う
// 関数の引数に参照渡しを行うことでdivImageの中身を書き換えることができる(値渡しでは書換不可)
//　https://qiita.com/agate-pris/items/05948b7d33f3e88b8967
// https://qiita.com/RuthTaro/items/f35c3a26779c0ca1a41a
int Image::LoadDivGraph(const TCHAR* FileName, DivImage& divImage)
{
  return DxLib::LoadDivGraph(FileName, divImage.XNum * divImage.YNum,
    divImage.XNum, divImage.YNum, divImage.XSize, divImage.YSize, divImage.HandleArray);
};

Boss.hを新規作成してif else でStateに応じて行動を遷移させてみましょう。

「登場」画面右から出てくる
　↓
「通常」通常の状態。通常の攻撃を行う
　↓
「気絶」気絶状態の絵になる
　↓
「発狂」怒った絵になる。激しい攻撃を繰り広げてくる
　↓
「死亡」少し時間をかけて死亡の演出を行う
　↓
完全に消滅

#ifndef BOSS_H_
#define BOSS_H_

#include "Enemy.h"

#include "Image.h"

// ボスクラス。Enemyを継承して作る
class Boss : public Enemy
{
public:
    // ボスの状態種別
    enum class State
    {
        Appear, // 登場
        Normal, // 通常時
        Swoon, // 気絶時
        Angry, // 発狂モード
        Dying, // 死亡
    };

    State state = State::Appear; // 現在の状態
    int swoonTime = 120; // 残り気絶時間
    int dyingTime = 180; // 死亡時のアニメーション時間

    // コンストラクタ
    Boss(Vector3 pos) : Enemy( pos )
    {
        this->tag = "Boss"; // オブジェクトの種類判別タグ
        life = 100; // ライフ
        collisionRadius = 70; // 当たり判定半径
    }

    // 更新処理
    void Update() override
    {
        if (state == State::Appear) // 登場状態
        {
            position.x -= 1; // 左へ移動

            if (position.x <= 750) // x座標が750以下になったら
            {
                state = State::Normal; // 通常状態へ移行
            }
        }
        else if (state == State::Normal) // 通常状態
        {
        }
        else if (state == State::Swoon) // 気絶状態
        {
            swoonTime--; // タイマー減少

            if (swoonTime <= 0) // タイマーが0になったら
            {
                state = State::Angry; // 発狂モードへ
            }
        }
        else if (state == State::Angry) // 発狂モード
        {
        }
        else if (state == State::Dying) // 死亡中
        {
            dyingTime--; // タイマー減少

            if (dyingTime <= 0) // タイマーが0になったら
            {
                isDead = true; // 完全に消滅
            }
        }
    }

    // 描画処理
    void Draw() override
    {
        if (state == State::Appear || state == State::Normal) // 登場時と通常時
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss1, TRUE); // 普通の画像
        }
        else if (state == State::Swoon) // 気絶時
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss2, TRUE); // 気絶時の画像
        }
        else if (state == State::Angry) // 発狂モード
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss3, TRUE); // 怒ってる画像
        }
        else if (state == State::Dying) // 死亡中
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss2, TRUE); // 気絶時の画像
        }
    }

    // 自機弾に当たったときの処理をoverride（上書き）する
    virtual void OnCollisionPlayerBullet(std::shared_ptr<GameObject> playerBullet) override
    {
        // 登場時、気絶時、死亡時は被弾しても何もしない
        if (state == State::Appear || state == State::Swoon || state == State::Dying)
            return;

        life -= 1; // ライフを減らす

        if (life <= 0)
        {
            // ライフが無くなったら、すぐ消滅するのではなく、死亡状態へ移行
            state = State::Dying;
        }
        else if (state == State::Normal && life <= 50)
        {
            // 通常状態でライフが50以下になったら、気絶する
            state = State::Swoon;
        }
    }
};

#endif

Game.cppにボスの生成処理を追加してボスが期待通りに状態遷移することを確認しましょう。

#include "Game.h"

#include "MyRandom.h"

#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h"
#include "EnemyBullet.h"
#include "Explosion.h"
#include "Zako0.h"
#include "Zako1.h"
#include "Zako2.h"
#include "Zako3.h"
#include "Boss.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理
    Image::Load(); //画像の読込み
    MyRandom::Init(); // 乱数シードの初期化

    (中略).................

    gm.player = std::make_shared<Player>(Vector3((float)100, (float)(Screen::Height / 2))); // 自機の初期化
    // とりあえず適当に敵を生成
    gm.enemies.emplace_back(std::make_shared<Boss>(Vector3(Screen::Width + 90, Screen::Height / 2)));
}

(以下略).................

【練習問題】ボスの状態ごとの行動パターンのプログラミング

さきほどのボスは登場してもじっとしたままです。
Zako0～Zako3の動きを応用して自分オリジナルのボスの行動パターンを自作してみてください。
例として下記に実装例を置いてはおきますがあくまで参考として、自分で考えて組んでみることが大事です。
ここまでの復習と集大成として、Zako0～Zako3のコードを移植しながら、プログラミングすることが肝要です。

Boss.hの行動パターンのプログラム例(lifeとenumの状態をAngry以外にも増やせばもっと長期戦も演出できる)

#ifndef BOSS_H_
#define BOSS_H_

#include "Enemy.h"

#include "Image.h"

#include <cmath> // Sin Cosの計算に使う
#include "MyMath.h"
#include "MyRandom.h" // 乱数方向弾に使う

// ボスクラス。Enemyを継承して作る
class Boss : public Enemy
{
public:
    // ボスの状態種別
    enum class State
    {
        Appear, // 登場
        Normal, // 通常時
        Swoon, // 気絶時
        Angry, // 発狂モード
        Dying, // 死亡
    };

    State state = State::Appear; // 現在の状態
    int swoonTime = 120; // 残り気絶時間
    int dyingTime = 180; // 死亡時のアニメーション時間

    int coolTime = 0; // クールタイム(冷却時間。0になるまで次の弾が撃てない)
    float sinMove = 0; // Sinの動きをする際の0～360度
    float sinRadius = 120; // Sinの動きをするときの半径

    // コンストラクタ
    Boss(Vector3 pos) : Enemy( pos )
    {
        this->tag = "Boss"; // オブジェクトの種類判別タグ
        life = 100; // ライフ
        collisionRadius = 70; // 当たり判定半径
    }

    // 更新処理
    void Update() override
    {
        if (state == State::Appear) // 登場状態
        {
            position.x -= 1; // 左へ移動

            if (position.x <= 750) // x座標が750以下になったら
            {
                state = State::Normal; // 通常状態へ移行
            }
        }
        else if (state == State::Normal) // 通常状態
        {
            coolTime--;
           
            if (coolTime <= 0)
            {   // ボスの弾はスピード16で2倍の速度で撃ち出す
                gm.enemyBullets.emplace_back(std::make_shared<EnemyBullet>(position, 180 * MyMath::Deg2Rad, 16));
                coolTime += 200; // そのかわり発射間隔は長め
            }
           
            float prevSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
            sinMove += 2.5f; // Sinの波運動の角度を進める
            float currentSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
           
            // (前の角度でのY) - (今の角度でのY)の差を足すことで【ベースのyの位置 ± sinの動き】になる
            position.y += currentSinY - prevSinY; // 上下方向のSinの波運動
        }
        else if (state == State::Swoon) // 気絶状態
        {
            swoonTime--; // タイマー減少

            if (swoonTime <= 0) // タイマーが0になったら
            {
                coolTime = 0; // クールタイムを0にリセットしてから
                state = State::Angry; // 発狂モードへ
            }
        }
        else if (state == State::Angry) // 発狂モード
        {
            coolTime--;
           
            if (coolTime <= 0)
            {
                gm.enemyBullets.emplace_back(std::make_shared<EnemyBullet>(position, 180 * MyMath::Deg2Rad, 16));
                coolTime += 20;
            }
           
            float prevSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
            sinMove += 10.5f; // Sinの波運動の角度を進める
            float currentSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
           
            // (前の角度でのY) - (今の角度でのY)の差を足すことで【ベースのyの位置 ± sinの動き】になる
            position.y += currentSinY - prevSinY; // 上下方向のSinの波運動
        }
        else if (state == State::Dying) // 死亡中
        {
            dyingTime--; // タイマー減少

            if (dyingTime <= 0) // タイマーが0になったら
            {
                isDead = true; // 完全に消滅
            }
        }
    }

    // 描画処理
    void Draw() override
    {
        if (state == State::Appear || state == State::Normal) // 登場時と通常時
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss1, TRUE); // 普通の画像
        }
        else if (state == State::Swoon) // 気絶時
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss2, TRUE); // 気絶時の画像
        }
        else if (state == State::Angry) // 発狂モード
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss3, TRUE); // 怒ってる画像
        }
        else if (state == State::Dying) // 死亡中
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss2, TRUE); // 気絶時の画像
        }
    }

    // 自機弾に当たったときの処理をoverride（上書き）する
    virtual void OnCollisionPlayerBullet(std::shared_ptr<GameObject> playerBullet) override
    {
        // 登場時、気絶時、死亡時は被弾しても何もしない
        if (state == State::Appear || state == State::Swoon || state == State::Dying)
            return;

        life -= 1; // ライフを減らす

        if (life <= 0)
        {
            // ライフが無くなったら、すぐ消滅するのではなく、死亡状態へ移行
            state = State::Dying;
        }
        else if (state == State::Normal && life <= 50)
        {
            // 通常状態でライフが50以下になったら、気絶する
            state = State::Swoon;
        }
    }
};

#endif

プレイヤのライフをバーで表示させる

Player.hに現在のライフをバーで表示する処理の定義を追加します。

#ifndef PLAYER_H_
#define PLAYER_H_

#include "DxLib.h"
#include "Input.h"
#include "Image.h"
#include "MyMath.h"

#include "GameObject.h"

#include "GameManager.h"

class Player : public GameObject
{ // 継承は↑: public ～にする。publicをつけ忘れるとGameObjectの変数がすべてprivateとして継承されちゃう
public:

  (中略)...........

  int lifeMax = 20; // 最大ライフ
  int life = 3; // ライフ
  int mutekiTimer = 0; // 残り無敵時間。0以下なら無敵じゃないってこと

  (中略)...........

  // 描画処理
  void Draw();//【★←Player.cppを新規作成してそちらに処理を書き移す】

  // ライフをバーで表示する処理
  void DrawLifeBar();

  // 敵にぶつかった時の処理
  void OnCollisionEnemy(std::shared_ptr<GameObject> other);

  // 敵弾とぶつかった時の処理
  void OnCollisionEnemyBullet(std::shared_ptr<GameObject> other);

  // ダメージを受ける処理
  void TakeDamage();
};

#endif

Player.cppに現在のライフをバーで表示する処理の定義を追加します。

#include "Player.h"

  (中略).........

// 更新処理
void Player::Update()
{
  (中略).........
}

// 描画処理
void Player::Draw()
{
  (中略).........
  
  // ライフをバーで表示する処理
  DrawLifeBar();
}

// ライフをバーで表示する処理
void Player::DrawLifeBar()
{
  // ライフをバー表示する際の色設定
  unsigned int frameColor = GetColor(255, 255, 255); // バーの枠の色
  unsigned int backColor = GetColor(0, 0, 0); // バーの背景の色
  unsigned int lineColor = GetColor(0, 0, 0); // バーの区切り目盛りの色
  unsigned int red = GetColor(255, 0, 0), orange = GetColor(255, 100, 0); // ピンチ時の赤、オレンジ
  unsigned int green = GetColor(0, 255, 0), blue = GetColor(0, 255, 255); // 10までは緑、11以上は水色
  int barMax = (lifeMax > 10) ? 10 : lifeMax; // バーの目盛りの数
  int barWidth = 40, barPart = barWidth / barMax, rectWidth = (barPart + 1) * barMax;
  int barHeight = 4; // バーの表示する高さ(4+1+1) 枠は上+1, 下+1, 目盛ぶん↑+1して×10し直すとバーの四角形幅になる
  Vector3 barPos{ position.x - rectWidth / 2, position.y + collisionRadius }; // バーの表示位置
  
  // バーの背景を描画
  DrawBox(barPos.x - 1, barPos.y - 1, barPos.x + 1 + rectWidth, barPos.y + 1 + barHeight, backColor, TRUE);
  // バーの枠を描画
  DrawBox(barPos.x - 1, barPos.y - 1, barPos.x + 1 + rectWidth, barPos.y + 1 + barHeight, frameColor, FALSE);
  auto barColor = (life <= 1) ? red : (life <= 2) ? orange : green; // lifeが 残り1:赤,残り2:橙 10以下:緑
  // バーの中身を10まで描画
  int barNum = (life < 10) ? life : 10;
  for (int i = 0; i < barNum; ++i)
    DrawBox(barPos.x + i * (barPart + 1), barPos.y,
            barPos.x + (i + 1) * (barPart + 1), barPos.y + barHeight, barColor, TRUE);
  // バーの中身(水色)を20まで描画
  int blueNum = (life > 20) ? 10 : (life > 10) ? life - 10 : 0; // lifeが残り10以上のときは水色
  for (int i = 0; i < blueNum; ++i)
    DrawBox(barPos.x + i * (barPart + 1), barPos.y,
            barPos.x + (i + 1) * (barPart + 1), barPos.y + barHeight, blue, TRUE);
  // バーの目盛りを描画
  for (int i = 0; i < 9; ++i)
    DrawLine(barPos.x + (i + 1) * (barPart + 1), barPos.y,
             barPos.x + (i + 1) * (barPart + 1), barPos.y + barHeight, (i + 1 == life) ? barColor : lineColor, TRUE);
}

  (以下略).........

アイテムクラスとザコからのドロップ処理の作成

ザコからプレイヤのライフを回復するアイテムをドロップさせてみましょう。
GIMPで16×16のハートのドット絵画像を自作してheart.pngという名前でpng画像としてDXプロジェクトのImageフォルダにエクスポートしておきましょう。

Image.hにheart.pngの読込み処理を追加します。

#ifndef IMAGE_H_
#define IMAGE_H_

#include "DxLib.h"
#include <assert.h> // 画像読み込みの読込み失敗表示用
#include "DivImage.h" // 分割画像の読込みに使う

class Image
{
public:
  Image() {}; // 初期化コンストラクタ:定義と{}空の処理
  ~Image() {}; // 破棄する処理デストラクタ:定義と{}空の処理
  static void Load();
  static int LoadDivGraph(const TCHAR* FileName, DivImage& divImage);

  static int bossImage; //ボス画像のハンドラ(読込画像番号)
  static int player; //プレイヤ画像のハンドラ
  static int playerBullet; //プレイヤの弾画像のハンドラ
  static int enemyBullet16; //敵弾 画像のハンドラ(読込画像番号)
  static int zako0; //ザコ0 画像のハンドラ(読込画像番号)
  static int zako1; //ザコ1 画像のハンドラ(読込画像番号)
  static int zako2; //ザコ2 画像のハンドラ(読込画像番号)
  static int zako3; //ザコ3 画像のハンドラ(読込画像番号)
  static int boss1; //ボス通常 画像のハンドラ(読込画像番号)
  static int boss2; //ボス2気絶 画像のハンドラ(読込画像番号)
  static int boss3; //ボス3発狂 画像のハンドラ(読込画像番号)
  static DivImage explosion; // [分割画像]爆発エフェクト
  static int item0; //アイテム0 画像のハンドラ(読込画像番号)

private:

};
#endif

次に対となるcppファイルも変更します。
Image.cppの内容を次のようにします：

#include "Image.h"

int Image::bossImage{-1}; // Load終わっても-1(初期値)のままだと画像ロードが失敗してますね
int Image::player{-1};
int Image::playerBullet{-1};
int Image::enemyBullet16{-1};
int Image::zako0{-1};
int Image::zako1{-1};
int Image::zako2{-1};
int Image::zako3{-1};
int Image::boss1{-1};
int Image::boss2{-1};
int Image::boss3{-1};
// ★分割画像は初期化のときに{X方向画像数, Y方向画像数, 画像横幅XSize,画像縦幅YSize}を指定
DivImage Image::explosion{ 8, 2, 64, 64 };
int Image::item0{-1};

void Image::Load()
{
  bossImage = LoadGraph("Image/boss1.png");
  assert(bossImage != -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  player= LoadGraph("Image/player.png");
  assert(player!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  playerBullet = LoadGraph("Image/player_bullet.png");
  assert(playerBullet!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  enemyBullet16 = LoadGraph("Image/enemy_bullet_16.png");
  assert(enemyBullet16!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako0 = LoadGraph("Image/zako0.png");
  assert(zako0!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako1 = LoadGraph("Image/zako1.png");
  assert(zako1!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako2 = LoadGraph("Image/zako2.png");
  assert(zako2!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako3 = LoadGraph("Image/zako3.png");
  assert(zako3!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  boss1 = LoadGraph("Image/boss1.png");
  assert(boss1!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  boss2 = LoadGraph("Image/boss2.png");
  assert(boss2!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  boss3 = LoadGraph("Image/boss3.png");
  assert(boss3!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  // div分割画像をロード
  Image::LoadDivGraph("Image/explosion.png", explosion);
  for (int i = 0; i < explosion.AllNum; i++)
  { // 画像読込失敗
    if (explosion.HandleArray[i] == -1) assert("爆発分割画像読込失敗" == "");
  }

  item0 = LoadGraph("Image/heart.png");
  assert(item0!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

}

// DXライブラリのLoadDivGraphを使いやすくラッピング
// ★関数に参照渡しを行う
// 関数の引数に参照渡しを行うことでdivImageの中身を書き換えることができる(値渡しでは書換不可)
//　https://qiita.com/agate-pris/items/05948b7d33f3e88b8967
// https://qiita.com/RuthTaro/items/f35c3a26779c0ca1a41a
int Image::LoadDivGraph(const TCHAR* FileName, DivImage& divImage)
{
  return DxLib::LoadDivGraph(FileName, divImage.XNum * divImage.YNum,
    divImage.XNum, divImage.YNum, divImage.XSize, divImage.YSize, divImage.HandleArray);
};

Player.hにライフを回復する処理を追加します。

#ifndef PLAYER_H_
#define PLAYER_H_

#include "DxLib.h"
#include "Input.h"
#include "Image.h"
#include "MyMath.h"

#include "GameObject.h"

#include "GameManager.h"

class Player : public GameObject
{ // 継承は↑: public ～にする。publicをつけ忘れるとGameObjectの変数がすべてprivateとして継承されちゃう
public:

  (中略)...........


  // ダメージを受ける処理
  void TakeDamage();

  // ライフが回復する処理
  void RecoverLife(int amount);
};

#endif

Player.cppにライフを回復する処理を追加します。

#include "Player.h"

  (中略).........

// 更新処理
void Player::Update()
{
  (中略).........
}


  (中略).........

// ダメージを受ける処理
void Player::TakeDamage()
{
  life -= 1; // ライフ減少

  if (life <= 0)
  {
    // ライフが無くなったら死亡
    isDead = true;
  }
  else
  {
    // 無敵時間発動
    mutekiTimer = MutekiJikan;
  }
}

// ライフが回復する処理
void Player::RecoverLife(int amount)
{
  life += amount; // ライフ回復
}

#ifndef ITEM_H_
#define ITEM_H_

#include "GameObject.h"

#include "GameManager.h"

// アイテムのベース基底クラス
class Item : public GameObject
{
public:
    //【仲介者パターン】ゲーム内のもの同士はマネージャを通して一元化してやり取り
    GameManager& gm = GameManager::GetInstance(); //唯一のゲームマネージャへの参照(&)を得る
   
    float collisionRadius; // 当たり判定の半径
   

    // コンストラクタ v:移動速度(方向) radius:当たり判定の半径
    Item(Vector3 pos, Vector3 v, float radius = 8)
        : collisionRadius{ radius }, GameObject( pos ) // GameObjectをベースとして初期化処理を継承する
    {
        this->typeTag = "Item"; // オブジェクトの種類判別タグ
        this->v = v; // GameObjectの速度vを利用する
    }

    // 更新処理。派生クラスでオーバーライドして使う
    virtual void Update() = 0;//virtual ～ = 0;で【純粋仮想関数に】これで【C#のabstract型に】

    // 描画処理。派生クラスでオーバーライドして使う
    virtual void Draw() = 0; //virtual ～ = 0;で【純粋仮想関数に】【関数 = 0で未定義状態を表現】

    // 自機に当たったときの処理 派生クラスでオーバーライドして使う
    virtual void OnCollisionPlayer(std::shared_ptr<GameObject> object)
    {
        // アイテムごとに継承でoverrideして個別処理を書く
    }
};

#endif

#ifndef ITEM_0_H_
#define ITEM_0_H_

#include "Item.h"
#include "Image.h"
#include "Screen.h"

// アイテム0クラス ライフを回復するアイテム
class Item0 : public Item
{
public:
    int amount; // 回復量など

    // コンストラクタ
    Item0(Vector3 pos,
          Vector3 v = Vector3{ -0.5f,0.0f }, // デフォルトは-0.5fで遅めのスクロール量
          int amount = 1)
        : amount{ amount }, Item(pos, v, 8)
    {
        this->tag = "Item0"; // オブジェクトの判別タグ
    }

    // 更新処理
    virtual void Update() override
    {
        this->position += this->v; // vのx,y量ぶん移動
        
        
        // スクリーンの画面外になったらisDeadにして消す
        if (position.x + collisionRadius < 0 || Screen::Width < position.x - collisionRadius
         || position.y + collisionRadius < 0 || Screen::Height < position.y - collisionRadius )
        {
            isDead = true;
        }
    }

    // 描画処理
    virtual void Draw() override
    {
        DrawRotaGraphF(position.x, position.y, 1, 0, Image::item0, TRUE);
    }

    // 自機に当たったときの処理 上書きoverrideする
    virtual void OnCollisionPlayer(std::shared_ptr<GameObject> object) override;
};

#endif

#include "Item0.h"

#include "Player.h" // アイテムとプレイヤは相互にインクルードしそうなのでcppで#include

// 自機に当たったときの処理 上書きoverrideする
void Item0::OnCollisionPlayer(std::shared_ptr<GameObject> object)
{
    //[共有ポインタをダウンキャスト(親GameObject → 子Playerに)]
    // https://cpprefjp.github.io/reference/memory/shared_ptr/dynamic_pointer_cast.html
    if (std::shared_ptr<Player> pPlayer = std::dynamic_pointer_cast<Player>(object))
    {
        pPlayer->RecoverLife(amount); // ライフを回復する
    }
    isDead = true; // 取ったら消される
}

まずはベースとなるEnemy.hにアイテムをドロップするvirtual仮想関数を追加して継承overrideできるように準備します。

#ifndef ENEMY_H_
#define ENEMY_H_

#include "GameObject.h"

#include "GameManager.h"

// 敵の基底クラス。
// 全ての敵は、このクラスを継承して作る。
// ★【勉強】abstract型はC++にない!!【純粋仮想関数】を使って作る
class Enemy : public GameObject
{
public:

  //【仲介者パターン】ゲーム内のもの同士はマネージャを通して一元化してやり取り
  GameManager& gm = GameManager::GetInstance(); //唯一のゲームマネージャへの参照(&)を得る

  float collisionRadius = 32; // 当たり判定の半径
  float life = 1; // 耐久力

  // コンストラクタ
  Enemy(Vector3 pos) : GameObject( pos ) // GameObjectをベースとして初期化処理を継承する
  {
    this->typeTag = "Enemy";
  }

  // 更新処理。派生クラスでオーバーライドして使う
  virtual void Update() = 0;//virtual ～ = 0;で【純粋仮想関数に】これで【C#のabstract型に】

  // 描画処理。派生クラスでオーバーライドして使う
  virtual void Draw() = 0; //virtual ～ = 0;で【純粋仮想関数に】【関数 = 0で未定義状態を表現】


  // 自機弾に当たったときの処理 関数の【★引数をGameObject型↓にすることで循環インクルード抑止】
  virtual void OnCollisionPlayerBullet(std::shared_ptr<GameObject> playerBullet)
  {
    life -= 1; // ライフを減らす

    // ライフが無くなったら、死亡
    if (life <= 0)
    {
      isDead = true;
    }
    
    DropItem(); // アイテムを落とす処理(落とすかどうかはoverrideされた関数次第)
  }
  
  // アイテムを落とす処理 継承overrideして各ザコごとに違うドロップを実装できる
  virtual void DropItem()
  {
    // 継承overrideして各ザコごとに違う処理を実装する
  }
};

#endif

例として、Zako1.hにアイテム0をドロップさせる処理を追加します。

#ifndef ZAKO_1_H_
#define ZAKO_1_H_

#include "Enemy.h"

#include <cmath> // Sinの計算に使う
#include "MyMath.h"
#include "Image.h"

#include "MyRandom.h" // 乱数でアイテムのドロップを抽選する
#include "Item0.h"

// ザコ1クラス
class Zako1 : public Enemy
{
public:
  float sinMove = 0; // Sinの動きをする際の0～360度
  float sinRadius = 70; // Sinの動きをするときの半径
  
  // コンストラクタ
  Zako1(Vector3 pos) : Enemy ( pos )
  {
    this->tag = "Zako1";//オブジェクトの種類判別タグ
    life = 5;
  }

  // 更新処理
  void Update() override
  {
    position.x -= 1; // 左へ移動

    float prevSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
    sinMove += 2.5f; // Sinの波運動の角度を進める
    float currentSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;

    // (前の角度でのY) - (今の角度でのY)の差を足すことで【ベースのyの位置 ± sinの動き】になる
    position.y += currentSinY - prevSinY; // 上下方向のSinの波運動
  }

  // 描画処理
  void Draw() override
  {
    DrawRotaGraphF(position.x, position.y, 1, 0, Image::zako1, TRUE);
  }

  // アイテムを落とす処理
  void DropItem() override
  {
    if (isDead) // 消えるまえに
    {
      if (MyRandom::Percent(50.0f)) // 50%の確率でアイテムをドロップ
      {
        gm.items.emplace_back(std::make_shared<Item0>(position));
      }
    }
  }
};

#endif

GameManager.hにItemを管理するリストの定義を追加します。

#ifndef GAMEMANAGER_H_
#define GAMEMANAGER_H_

#include <memory>
#include <vector>

#include "Singleton.h"

class Player; // クラス宣言だけで★インクルードしないのでこのマネージャファイルで循環は止まる
class PlayerBullet;
class Enemy;
class EnemyBullet;
class Explosion;
class Item;

class GameManager : public Singleton<GameManager>//←<～>として継承すると唯一のシングルトン型タイプとなる
{
public:
  friend class Singleton<GameManager>; // Singleton でのインスタンス作成は許可

  std::shared_ptr<Player> player{ nullptr }; // 自機のポインタ
  std::list<std::shared_ptr<PlayerBullet>> playerBullets; // 自機弾のリスト
  std::list<std::shared_ptr<Enemy>> enemies; // 敵のリスト
  std::list<std::shared_ptr<EnemyBullet>> enemyBullets; // 敵弾のリスト
  std::list<std::shared_ptr<Explosion>> explosions; // 爆発エフェクトのリスト
  std::list<std::shared_ptr<Item>> items; // アイテムのリスト
  // 複数リスト↑list ↑【shared_ptr】回し読みポインタ:メモリにデータを回し読み状態として確保できる


(中略)..............
protected:
  GameManager() {}; // 外部からのインスタンス作成は禁止
  virtual ~GameManager() {}; //外部からのインスタンス破棄も禁止
};

#endif

Game.cppにアイテムの当たり判定の処理を追加します。

#include "Game.h"

#include "MyRandom.h"

#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "EnemyBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Explosion.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako1.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako2.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako3.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako3.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Item.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  (中略)..................
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  (中略)..................

  
  // 爆発エフェクトの更新処理
  for (const auto& e : gm.explosions)
  {
    e->Update();
  }
  
  // アイテムの更新処理
  for (const auto& itm : gm.items)
  {
    itm->Update();
  }
  
  
  // 自機とアイテムの衝突判定
  for (const auto& itm : gm.items)
  {
    // 自機が死んでたらこれ以上判定しない
    if (gm.player->isDead)
      break;
    
    // アイテムが死んでたらスキップ
    if (itm->isDead)
      continue;
    
    // 円同士の衝突判定で調べる
    if (MyMath::CircleCircleIntersection(
        gm.player->position, gm.player->collisionRadius,
        itm->position, itm->collisionRadius) )
    {
      itm->OnCollisionPlayer(gm.player);
    }
  }
  

  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.playerBullets,
    [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  // 敵のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemies,
    [](std::shared_ptr<Enemy>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  // 敵弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemyBullets,
    [](std::shared_ptr<EnemyBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  //爆発エフェクトのリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.explosions,
    [](std::shared_ptr<Explosion>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  //アイテムのリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.items,
    [](std::shared_ptr<Item>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
};

void Game::Draw()
{// 描画処理
  (中略)......

  // 敵弾の描画処理
  for (const auto& b : gm.enemyBullets)
  {
    b->Draw();
  }
  
  // アイテムの描画処理
  for (const auto& itm : gm.items)
  {
    itm->Draw();
  }
}

Item0を画面のはしっこで光らせてバウンドさせる処理の作成

#ifndef ITEM_0_H_
#define ITEM_0_H_

#include "Item.h"
#include "Image.h"
#include "Screen.h"

// アイテム0クラス ライフを回復するアイテム
class Item0 : public Item
{
public:
    int amount; // 回復量など
    int bounceNum; // 跳ね返る回数
    bool isFlash; // 画面が一瞬真っ白になる(跳ね返る瞬間)

    // コンストラクタ
    Item0(Vector3 pos,
          Vector3 v = Vector3{ -0.5f,0.0f }, // デフォルトは-0.5fで遅めのスクロール量
          bool isFlash = false, int bounceNum = 0,
          int amount = 1)
        : isFlash{ isFlash }, bounceNum{ bounceNum }, amount{ amount }, Item(pos, v, 8)
    {
        this->tag = "Item0"; // オブジェクトの判別タグ
    }

    // 更新処理
    virtual void Update() override
    {
        this->position += this->v; // vのx,y量ぶん移動
        
        if (bounceNum > 0) // 反射可能回数が 0 以上なら
        {
            bool isBounce = false; // 反射するか
            if (position.x < collisionRadius)
            {
                v.x = -v.x; // x逆方向に反射(マイナスをつけて方向反転)
                position.x = collisionRadius; // めりこんだぶんをスクリーンの境界線に沿わす
                isBounce = true;
            }
            else if (Screen::Width - collisionRadius < position.x)
            {
                v.x = -v.x; // x逆方向に反射(マイナスをつけて方向反転)
                position.x = Screen::Width - collisionRadius; // めりこんだぶんを境界線に沿わす
                isBounce = true;
            }
            
            if (position.y < collisionRadius)
            {
                v.y = -v.y; // y逆方向に反射(マイナスをつけて方向反転)
                position.y = collisionRadius; // めりこんだぶんをスクリーンの境界線に沿わす
                isBounce = true;
            }
            else if (Screen::Height - collisionRadius < position.y)
            {
                v.y = -v.y; // y逆方向に反射(マイナスをつけて方向反転)
                position.y = Screen::Height - collisionRadius; // めりこんだぶんを境界線に沿わす
                isBounce = true;
            }
            
            if (isBounce) // 反射判定がtrueならば
            {
                --bounceNum; // 跳ね返り可能回数を -1 する
                v *= 0.94f; // 反射時のスピード減衰率
                isFlash = true; // 画面を一瞬フラッシュする
            }
        }
        
        
        // スクリーンの画面外になったらisDeadにして消す
        if (position.x + collisionRadius < 0 || Screen::Width < position.x - collisionRadius
         || position.y + collisionRadius < 0 || Screen::Height < position.y - collisionRadius )
        {
            isDead = true;
        }
    }

    // 描画処理
    virtual void Draw() override
    {
        if (isFlash) // 画面を一瞬真っ白にする(跳ね返る瞬間)
        {
            // 画面のスクリーンと同じサイズの大きな白い四角を描く
            DrawBox(0, 0, Screen::Width, Screen::Height, GetColor(200, 200, 200), TRUE);
            // 白画面の上に黒丸を描くとバウンド位置が目立つ(衝撃波っぽい)
            DrawCircle(position.x, position.y, collisionRadius * 5, GetColor(0, 0, 0), TRUE);
        }
       
        DrawRotaGraphF(position.x, position.y, (isFlash)? 2.0f : 1, 0, Image::item0, TRUE);
       
        isFlash = false; // すぐにfalseに戻せば一瞬だけしか光らない
    }

    // 自機に当たったときの処理 上書きoverrideする
    void OnCollisionPlayer(std::shared_ptr<GameObject> object) override;
};

#endif

例として、Zako1.hにアイテム0の初速度と反射する回数と乱数で飛ぶ角度を決めて初期化する処理を追加します。

#ifndef ZAKO_1_H_
#define ZAKO_1_H_

#include "Enemy.h"

#include <cmath> // Sinの計算に使う
#include "MyMath.h"
#include "Image.h"

#include "MyRandom.h" // 乱数でアイテムのドロップと飛ぶ角度を抽選する
#include "Item0.h"

// ザコ1クラス
class Zako1 : public Enemy
{
public:
  float sinMove = 0; // Sinの動きをする際の0～360度
  float sinRadius = 70; // Sinの動きをするときの半径
  
  // コンストラクタ
  Zako1(Vector3 pos) : Enemy ( pos )
  {
    this->tag = "Zako1";//オブジェクトの種類判別タグ
    life = 5;
  }

  // 更新処理
  void Update() override
  {
    position.x -= 1; // 左へ移動

    float prevSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
    sinMove += 2.5f; // Sinの波運動の角度を進める
    float currentSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;

    // (前の角度でのY) - (今の角度でのY)の差を足すことで【ベースのyの位置 ± sinの動き】になる
    position.y += currentSinY - prevSinY; // 上下方向のSinの波運動
  }

  // 描画処理
  void Draw() override
  {
    DrawRotaGraphF(position.x, position.y, 1, 0, Image::zako1, TRUE);
  }

  // アイテムを落とす処理
  void DropItem() override
  {
    if (isDead) // 消えるまえに
    {
      if (MyRandom::Percent(50.0f)) // 50%の確率でアイテムをドロップ
      {
        float itemSpeed = 25.0f; // アイテムの飛び出すスピード
        float angle = MyRandom::Range(0.0f, 360.0f) * MyMath::Deg2Rad; // 飛び出す角度
        Vector3 v_Item{ std::cos(angle) * itemSpeed, std::sin(angle) * itemSpeed }; // 飛ぶ方向ベクトル
        int bounceNum = 10; // バウンド回数
        gm.items.emplace_back(std::make_shared<Item0>(position, v_Item, true, bounceNum));
      }
    }
  }
};

#endif

Item1クラスでボスへクリティカルヒットしたらバリアーとなる星のアイテムをドロップする処理の作成

ボスから「プレイヤの周りをまわって、敵の弾からプレイヤを守る星バリアのアイテム」をドロップさせてみましょう。
GIMPで16×16のスターのドット絵画像を自作してstar.pngという名前でpng画像としてDXプロジェクトのImageフォルダにエクスポートしておきましょう。

Image.hにstar.pngの読込み処理を追加します。

#ifndef IMAGE_H_
#define IMAGE_H_

#include "DxLib.h"
#include <assert.h> // 画像読み込みの読込み失敗表示用
#include "DivImage.h" // 分割画像の読込みに使う

class Image
{
public:
  Image() {}; // 初期化コンストラクタ:定義と{}空の処理
  ~Image() {}; // 破棄する処理デストラクタ:定義と{}空の処理
  static void Load();
  static int LoadDivGraph(const TCHAR* FileName, DivImage& divImage);

  static int bossImage; //ボス画像のハンドラ(読込画像番号)
  static int player; //プレイヤ画像のハンドラ
  static int playerBullet; //プレイヤの弾画像のハンドラ
  static int enemyBullet16; //敵弾 画像のハンドラ(読込画像番号)
  static int zako0; //ザコ0 画像のハンドラ(読込画像番号)
  static int zako1; //ザコ1 画像のハンドラ(読込画像番号)
  static int zako2; //ザコ2 画像のハンドラ(読込画像番号)
  static int zako3; //ザコ3 画像のハンドラ(読込画像番号)
  static int boss1; //ボス通常 画像のハンドラ(読込画像番号)
  static int boss2; //ボス2気絶 画像のハンドラ(読込画像番号)
  static int boss3; //ボス3発狂 画像のハンドラ(読込画像番号)
  static DivImage explosion; // [分割画像]爆発エフェクト
  static int item0; //アイテム0 画像のハンドラ(読込画像番号)
  static int item1; //アイテム1 画像のハンドラ(読込画像番号)

private:

};
#endif

次に対となるcppファイルも変更します。
Image.cppの内容を次のようにします：

#include "Image.h"

int Image::bossImage{-1}; // Load終わっても-1(初期値)のままだと画像ロードが失敗してますね
int Image::player{-1};
int Image::playerBullet{-1};
int Image::enemyBullet16{-1};
int Image::zako0{-1};
int Image::zako1{-1};
int Image::zako2{-1};
int Image::zako3{-1};
int Image::boss1{-1};
int Image::boss2{-1};
int Image::boss3{-1};
// ★分割画像は初期化のときに{X方向画像数, Y方向画像数, 画像横幅XSize,画像縦幅YSize}を指定
DivImage Image::explosion{ 8, 2, 64, 64 };
int Image::item0{-1};
int Image::item1{-1};

void Image::Load()
{
  bossImage = LoadGraph("Image/boss1.png");
  assert(bossImage != -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  player= LoadGraph("Image/player.png");
  assert(player!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  playerBullet = LoadGraph("Image/player_bullet.png");
  assert(playerBullet!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  enemyBullet16 = LoadGraph("Image/enemy_bullet_16.png");
  assert(enemyBullet16!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako0 = LoadGraph("Image/zako0.png");
  assert(zako0!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako1 = LoadGraph("Image/zako1.png");
  assert(zako1!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako2 = LoadGraph("Image/zako2.png");
  assert(zako2!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  zako3 = LoadGraph("Image/zako3.png");
  assert(zako3!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  boss1 = LoadGraph("Image/boss1.png");
  assert(boss1!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  boss2 = LoadGraph("Image/boss2.png");
  assert(boss2!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  boss3 = LoadGraph("Image/boss3.png");
  assert(boss3!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  // div分割画像をロード
  Image::LoadDivGraph("Image/explosion.png", explosion);
  for (int i = 0; i < explosion.AllNum; i++)
  { // 画像読込失敗
    if (explosion.HandleArray[i] == -1) assert("爆発分割画像読込失敗" == "");
  }

  item0 = LoadGraph("Image/heart.png");
  assert(item0!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

  item1 = LoadGraph("Image/star.png");
  assert(item1!= -1); // 画像読込失敗、ファイル名かフォルダ名が間違ってる

}

// DXライブラリのLoadDivGraphを使いやすくラッピング
// ★関数に参照渡しを行う
// 関数の引数に参照渡しを行うことでdivImageの中身を書き換えることができる(値渡しでは書換不可)
//　https://qiita.com/agate-pris/items/05948b7d33f3e88b8967
// https://qiita.com/RuthTaro/items/f35c3a26779c0ca1a41a
int Image::LoadDivGraph(const TCHAR* FileName, DivImage& divImage)
{
  return DxLib::LoadDivGraph(FileName, divImage.XNum * divImage.YNum,
    divImage.XNum, divImage.YNum, divImage.XSize, divImage.YSize, divImage.HandleArray);
};

#ifndef ITEM_H_
#define ITEM_H_

#include "GameObject.h"

#include "GameManager.h"

// アイテムのベース基底クラス
class Item : public GameObject
{
public:
    //【仲介者パターン】ゲーム内のもの同士はマネージャを通して一元化してやり取り
    GameManager& gm = GameManager::GetInstance(); //唯一のゲームマネージャへの参照(&)を得る
   
    float collisionRadius; // 当たり判定の半径
   
    enum class CollisionTo // 当たり判定の対象(ビット32桁に1を立てて表現)
    {
        None = 0,
        Player      = 0b0000'0000'0000'0000'0000'0000'0000'0001,
        EnemyBullet = 0b0000'0000'0000'0000'0000'0000'0000'0010,
    };
   
    CollisionTo collisionTo = CollisionTo::Player; // デフォルトはプレイヤとの当たりを判定する

    // コンストラクタ v:移動速度(方向) radius:当たり判定の半径
    Item(Vector3 pos, Vector3 v, float radius = 8)
        : collisionRadius{ radius }, GameObject( pos ) // GameObjectをベースとして初期化処理を継承する
    {
        this->typeTag = "Item"; // オブジェクトの種類判別タグ
        this->v = v; // GameObjectの速度vを利用する
    }

    // 更新処理。派生クラスでオーバーライドして使う
    virtual void Update() = 0;//virtual ～ = 0;で【純粋仮想関数に】これで【C#のabstract型に】

    // 描画処理。派生クラスでオーバーライドして使う
    virtual void Draw() = 0; //virtual ～ = 0;で【純粋仮想関数に】【関数 = 0で未定義状態を表現】

    // 自機に当たったときの処理 派生クラスでオーバーライドして使う
    virtual void OnCollisionPlayer(std::shared_ptr<GameObject> object)
    {
        // アイテムごとに継承でoverrideして個別処理を書く
    }
    
    // 敵弾とぶつかった時の処理
    virtual void OnCollisionEnemyBullet(std::shared_ptr<GameObject> object)
    {
        // アイテムごとに継承でoverrideして個別処理を書く
    }
};

#endif

#ifndef ITEM_1_H_
#define ITEM_1_H_

#include "Item.h"
#include "Image.h"
#include "Screen.h"
#include "MyMath.h"
#include <cmath>

// アイテム1クラス プレイヤを敵弾から守り身代わりになるバリアアイテム
class Item1 : public Item
{
public:
    int life; // バリアー(星)の耐える回数
    float xForce = 0.1f; // 加速の力(流れ星の加速)
    enum class State
    {
        Popping, // ポップ(飛び出した勢いのあるあいだ)
        Shooting,// 流れ星(加速して流れていく)
        Barrier, // バリアモードのとき
    };
    State state = State::Popping; // 動作状態
    GameObject* pParent{ nullptr }; // 親となっているプレイヤなどへのリンク(バリアの中心点)
    float barrierRadius; // バリアの円回転の半径
    float barrierAngle = 0.0f; // バリアの回転角度
    bool isHiting = false; // 敵弾にヒットした時に一瞬拡大して表示

    // コンストラクタ
    Item1(Vector3 pos,
          Vector3 v = Vector3{ -0.5f,0.0f }, // デフォルトは-0.5fで遅めのスクロール量
          int life = 3, float xForce = 0.8f, float barrierRadius = 40.0f)
        : life{ life }, xForce{ xForce }, barrierRadius{ barrierRadius },
          Item(pos, v, 8)
    {
        this->tag = "Item1"; // オブジェクトの判別タグ
    }

    // 更新処理
    virtual void Update() override
    {
        if (state == State::Popping) // 飛び出した勢いは段々減る
        {
            position += v; // vのx,y量ぶん移動
            v *= 0.85f; // 速度が減衰
            if (v.magnitude() < 0.01f)
                state = State::Shooting; // 流れ星モードに移行
        }
        else if (state == State::Shooting)
        {
            position += v; // vのx,y量ぶん移動
            v.x -= xForce; // 流れ星が少しずつ加速する
        }
        else if (state == State::Barrier && pParent != nullptr)
        {
            barrierAngle += 5.5f; // 毎フレーム5.5度ずつ回転
            position.x = pParent->position.x + barrierRadius * std::cos(barrierAngle * MyMath::Deg2Rad);
            position.y = pParent->position.y + barrierRadius * std::sin(barrierAngle * MyMath::Deg2Rad);
            
            if (pParent->isDead)
                isDead = true; // 親のプレイヤリンク先がisDeadなら連動して消す
        }
        
        if (state != State::Barrier) // バリア状態でないときに画面外に出たら消す
        {
            // スクリーンの画面外になったらisDeadにして消す
            if (position.x + collisionRadius < 0 || Screen::Width < position.x - collisionRadius
             || position.y + collisionRadius < 0 || Screen::Height < position.y - collisionRadius )
            {
                isDead = true;
            }
        }
    }

    // 描画処理
    virtual void Draw() override
    {
        DrawRotaGraphF(position.x, position.y, (isHiting)? 2.0f : 1, 0, Image::item1, TRUE);
    }

    // 自機に当たったときの処理 上書きoverrideする
    virtual void OnCollisionPlayer(std::shared_ptr<GameObject> object) override;

    // 敵弾とぶつかった時の処理
    virtual void OnCollisionEnemyBullet(std::shared_ptr<GameObject> object) override
    {
        if (!((int)collisionTo & (int)CollisionTo::EnemyBullet))
            return; // 敵弾と当たり判定しない設定のときは何もせずreturn
        
        if (life <= 0) // ライフ(バリアの耐久回数)が0以下になったら
        {
            isDead = true; // 当たった直後に消える
            isHiting = true; // 一瞬拡大して表示
        }
        
        --life; // ライフ(バリアの耐久回数)を減らす
    }
};

#endif

#include "Item1.h"

#include "Player.h" // アイテムとプレイヤは相互にインクルードしそうなのでcppで#include

// 自機に当たったときの処理 上書きoverrideする
void Item1::OnCollisionPlayer(std::shared_ptr<GameObject> object)
{
    if (!((int)collisionTo & (int)CollisionTo::Player))
        return; // プレイヤと当たり判定しないenumビット設定のときは何もせずreturn
   
    //[共有ポインタをダウンキャスト(親GameObject → 子Playerに)]
    // https://cpprefjp.github.io/reference/memory/shared_ptr/dynamic_pointer_cast.html
    if (std::shared_ptr<Player> pPlayer = std::dynamic_pointer_cast<Player>(object))
    {
        pParent = pPlayer.get(); // プレイヤへのリンクを親リンクとしてリンクされた(x,y)を中心に回転
        state = State::Barrier; // バリアモードへ移行
        collisionTo = CollisionTo::EnemyBullet; // 敵弾との当たり判定モードに移行
    }
}

#include "Item0.h"

#include "Player.h" // アイテムとプレイヤは相互にインクルードしそうなのでcppで#include

// 自機に当たったときの処理 上書きoverrideする
void Item0::OnCollisionPlayer(std::shared_ptr<GameObject> object)
{
    if (!((int)collisionTo & (int)CollisionTo::Player))
        return; // プレイヤと当たり判定しないenumビット設定のときは何もせずreturn
   
    //[共有ポインタをダウンキャスト(親GameObject → 子Playerに)]
    // https://cpprefjp.github.io/reference/memory/shared_ptr/dynamic_pointer_cast.html
    if (std::shared_ptr<Player> pPlayer = std::dynamic_pointer_cast<Player>(object))
    {
           pPlayer->RecoverLife(amount); // ライフを回復する
    }
    isDead = true; // 取ったら消される
}

例としてBoss.hで弾が当たったy位置が ±5 以内のときクリティカルと判定してバリアーの星を出す処理を追加します。

#ifndef BOSS_H_
#define BOSS_H_

#include "Enemy.h"

#include "Image.h"

#include <cmath> // Sin Cosの計算に使う
#include "MyMath.h"
#include "MyRandom.h" // 乱数方向弾とバリアーの星の飛び出す方向の抽選に使う
#include "Item1.h"
#include "PlayerBullet.h"

// ボスクラス。Enemyを継承して作る
class Boss : public Enemy
{
public:
    // ボスの状態種別
    enum class State
    {
        Appear, // 登場
        Normal, // 通常時
        Swoon, // 気絶時
        Angry, // 発狂モード
        Dying, // 死亡
    };

    State state = State::Appear; // 現在の状態
    int swoonTime = 120; // 残り気絶時間
    int dyingTime = 180; // 死亡時のアニメーション時間

    int coolTime = 0; // クールタイム(冷却時間。0になるまで次の弾が撃てない)
    float sinMove = 0; // Sinの動きをする際の0～360度
    float sinRadius = 120; // Sinの動きをするときの半径

    bool isCritical = false; // 弾に当たった瞬間の yが ±2 以内のときクリティカルと判定
    Vector3 criticalPos{0,0,0}; // クリティカルヒットした位置

    // コンストラクタ
    Boss(Vector3 pos) : Enemy( pos )
    {
        this->tag = "Boss"; // オブジェクトの種類判別タグ
        life = 100; // ライフ
        collisionRadius = 70; // 当たり判定半径
    }

    // 更新処理
    void Update() override
    {
        if (state == State::Appear) // 登場状態
        {
            position.x -= 1; // 左へ移動

            if (position.x <= 750) // x座標が750以下になったら
            {
                state = State::Normal; // 通常状態へ移行
            }
        }
        else if (state == State::Normal) // 通常状態
        {
            coolTime--;
           
            if (coolTime <= 0)
            {   // ボスの弾はスピード16で2倍の速度で撃ち出す
                gm.enemyBullets.emplace_back(std::make_shared<EnemyBullet>(position, 180 * MyMath::Deg2Rad, 16));
                coolTime += 200; // そのかわり発射間隔は長め
            }
           
            float prevSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
            sinMove += 2.5f; // Sinの波運動の角度を進める
            float currentSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
           
            // (前の角度でのY) - (今の角度でのY)の差を足すことで【ベースのyの位置 ± sinの動き】になる
            position.y += currentSinY - prevSinY; // 上下方向のSinの波運動
        }
        else if (state == State::Swoon) // 気絶状態
        {
            swoonTime--; // タイマー減少

            if (swoonTime <= 0) // タイマーが0になったら
            {
                coolTime = 0; // クールタイムを0にリセットしてから
                state = State::Angry; // 発狂モードへ
            }
        }
        else if (state == State::Angry) // 発狂モード
        {
            coolTime--;
           
            if (coolTime <= 0)
            {
                gm.enemyBullets.emplace_back(std::make_shared<EnemyBullet>(position, 180 * MyMath::Deg2Rad, 16));
                coolTime += 20;
            }
           
            float prevSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
            sinMove += 10.5f; // Sinの波運動の角度を進める
            float currentSinY = std::sin(sinMove * MyMath::Deg2Rad) * sinRadius;
           
            // (前の角度でのY) - (今の角度でのY)の差を足すことで【ベースのyの位置 ± sinの動き】になる
            position.y += currentSinY - prevSinY; // 上下方向のSinの波運動
        }
        else if (state == State::Dying) // 死亡中
        {
            dyingTime--; // タイマー減少

            if (dyingTime <= 0) // タイマーが0になったら
            {
                isDead = true; // 完全に消滅
            }
        }
    }

    // 描画処理
    void Draw() override
    {
        if (state == State::Appear || state == State::Normal) // 登場時と通常時
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss1, TRUE); // 普通の画像
        }
        else if (state == State::Swoon) // 気絶時
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss2, TRUE); // 気絶時の画像
        }
        else if (state == State::Angry) // 発狂モード
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss3, TRUE); // 怒ってる画像
        }
        else if (state == State::Dying) // 死亡中
        {
            DrawRotaGraphF(position.x, position.y, 1, 0, Image::boss2, TRUE); // 気絶時の画像
        }
       
        if (isCritical)
        {
            // 画面のスクリーンと同じサイズの大きな白い四角(フラッシュ)を描く
            DrawBox(0, 0, Screen::Width, Screen::Height, GetColor(200, 200, 200), TRUE);
            // 白フラッシュの上に黒丸を描くとクリティカルヒットした位置が目立つ(衝撃波っぽい)
            DrawCircle(position.x, position.y, 10, GetColor(0, 0, 0), TRUE);
            isCritical = false; // クリティカルフラグをfalseにすぐ戻す(フラッシュ点滅)
        }
    }

    // 自機弾に当たったときの処理をoverride（上書き）する
    void OnCollisionPlayerBullet(std::shared_ptr<GameObject> playerBullet) override
    {
        // 登場時、気絶時、死亡時は被弾しても何もしない
        if (state == State::Appear || state == State::Swoon || state == State::Dying)
            return;

        life -= 1; // ライフを減らす

        float posY = position.y; // [ボス中心y]と[当たった瞬間の弾のy]が ±5 ならクリティカル
        if (posY - 5 <= playerBullet->position.y && playerBullet->position.y <= posY + 5)
        {
            isCritical = true; // クリティカルフラグをtrueに
            criticalPos = playerBullet->position; // クリティカルヒットした位置を記録する
            DropItem(); // バリアの星アイテムを落とす
        }

        if (life <= 0)
        {
            // ライフが無くなったら、すぐ消滅するのではなく、死亡状態へ移行
            state = State::Dying;
        }
        else if (state == State::Normal && life <= 50)
        {
            // 通常状態でライフが50以下になったら、気絶する
            state = State::Swoon;
        }
    }
    
    // アイテムを落とす処理
    void DropItem() override
    {
        if (MyRandom::Percent(100.0f)) // 100%の確率でバリアになる星をドロップ
        {
            float itemSpeed = 25.0f; // アイテムの飛び出すスピード
            float angle = MyRandom::Range(0.0f, 360.0f) * MyMath::Deg2Rad; // 飛び出す角度
            Vector3 v_Item{ std::cos(angle) * itemSpeed, std::sin(angle) * itemSpeed }; // 飛ぶ方向ベクトル
            int barrierLife = 3; // バリアは敵弾に3回当たるまでガードしてくれる
            gm.items.emplace_back(std::make_shared<Item1>(position, v_Item, barrierLife));
        }
    }
};

#endif

EnemyBullet.hにアイテムと衝突したさいの関数を追加します。

#ifndef ENEMYBULLET_H_
#define ENEMYBULLET_H_

#include <cmath> //sin,cosを使うのに必要

#include "DxLib.h"
#include "Image.h"
#include "Screen.h"
#include "Vector3.h"

#include "GameObject.h"

// 敵弾クラス
class EnemyBullet: public GameObject
{
public:
  const int VisibleRadius = 8; // 見た目の半径
  

  float angle; // 移動角度(垂直Vertical)
  float angleH=0; // 移動角度(水平Horizontal)


  // コンストラクタ
  EnemyBullet(Vector3 pos, float angle, float speed) : GameObject( pos )
  {
    this->angle = angle;

    // 角度からx方向の移動速度を算出
    v.x = (float)std::cos(angle) * speed;
    // 角度からy方向の移動速度を算出
    v.y = (float)std::sin(angle) * speed;
  }

  // コンストラクタ
  EnemyBullet(Vector3 pos, float angleV, float angleH, float speed) : GameObject( pos )
  {
    this->angle = angleV;
    this->angleH = angleH;

    // [3Dの角度は水平・垂直に分割]https://teratail.com/questions/126004
    float cosAngleV = (float)std::cos(angle);
    // 角度からx方向の移動速度を算出
    v.x = cosAngleV * (float)std::sin(angleH) * speed;
    // 角度からy方向の移動速度を算出
    v.y = (float)std::sin(angle) * speed;
    // 角度からz方向の移動速度を算出
    v.z = cosAngleV * (float)std::cos(angleH) * speed;
  }

  // 更新処理
  void Update()
  {
    // 速度の分だけ移動
    position += v;

    // 画面外に出たら死亡フラグを立てる
    if (position.y + VisibleRadius < 0 || position.y - VisibleRadius > Screen::Height ||
      position.x + VisibleRadius < 0 || position.x - VisibleRadius > Screen::Width)
    {
      isDead = true;
    }
  }

  // 描画処理
  void Draw()
  {
    DrawRotaGraphF(position.x, position.y, 1, angle, Image::enemyBullet16,TRUE);
  }

  // プレイヤにぶつかった時の処理
  void OnCollisionPlayer(std::shared_ptr<GameObject> other)
  {
    isDead = true;
  }

  // アイテム(プレイヤの回りをまわるバリア)にぶつかった時の処理
  void OnCollisionItem(std::shared_ptr<GameObject> other)
  {
    isDead = true;
  }
};

#endif

Game.cppにアイテムの当たり判定の処理を追加します。

#include "Game.h"

#include "MyRandom.h"

#include "Player.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "PlayerBullet.h // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "EnemyBullet.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Explosion.h" // Update(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako0.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako1.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako2.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako3.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Zako3.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】
#include "Item.h" // 初期化やUpdate(),Draw()など【実際の処理を行うのでインクルード必要】

void Game::Init()
{// Init処理

  (中略)..................
};

void Game::Update()
{// 更新処理

  Input::Update(); //【注意】これ忘れるとキー入力押してもキャラ動かない

  (中略)..................

  
  // 爆発エフェクトの更新処理
  for (const auto& e : gm.explosions)
  {
    e->Update();
  }
  
  // アイテムの更新処理
  for (const auto& itm : gm.items)
  {
    itm->Update();
  }
  
  
  // 自機とアイテム、敵弾とアイテムの衝突判定
  for (const auto& itm : gm.items)
  {
    // 自機が死んでたらこれ以上判定しない
    if (gm.player->isDead)
      break;
    
    // アイテムが死んでたらスキップ
    if (itm->isDead)
      continue;
    
    // 円同士の衝突判定で調べる
    if (MyMath::CircleCircleIntersection(
        gm.player->position, gm.player->collisionRadius,
        itm->position, itm->collisionRadius) )
    {
      itm->OnCollisionPlayer(gm.player);
    }
    
    for (const auto& enemyBullet : gm.enemyBullets)
    {
      // 敵弾が死んでたらスキップ
      if (enemyBullet->isDead)
        continue;
      
      // 円同士の衝突判定で調べる
      if (MyMath::CircleCircleIntersection(
          itm->position, itm->collisionRadius,
          enemyBullet->position, enemyBullet->collisionRadius) )
      {
        enemyBullet->OnCollisionItem(itm);
        itm->OnCollisionEnemyBullet(enemyBullet);
      }
    }
  }
  

  //return; //【★実験】ここでreturnで処理を終わると弾のメモリを解放しない！下のerase前でそこまで処理が行かないからメモリ解放せずに終わる実験
  
  // 自機弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.playerBullets,
    [](std::shared_ptr<PlayerBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  // 敵のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemies,
    [](std::shared_ptr<Enemy>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  // 敵弾のリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.enemyBullets,
    [](std::shared_ptr<EnemyBullet>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  //爆発エフェクトのリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.explosions,
    [](std::shared_ptr<Explosion>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  //アイテムのリストから死んでるものを除去する
  gm.EraseRemoveIf(gm.items,
    [](std::shared_ptr<Item>& ptr) { return ptr->isDead; });//isDead==trueの条件のものを削除
  
};

void Game::Draw()
{// 描画処理
  (中略)......
}

[C++]シューティングゲーム 4

1. シーンを分ける(循環インクルードを避けメモリも管理するには?)
   【高難度】画面やステージごとにImageのメモリを開放する
   サウンドの読込みと再生機能
   【高難度】画面やステージごとにサウンドをメモリ読込み・解放(音量調整機能も追加)
   
2. CSVを読み込んで敵を生成するプログラム
   カスタムしたデータ構造DataCsv.hでデータ自身にLoadと幅高さ管理を任せる
   【高難度】敵データの全方位読出しアルゴリズム
   
3. 自機狙い弾
4. 自機に向かってくる敵



次のテキスト5はこちら。


[C++]シューティングゲーム 5【応用1】

シーンを分ける(循環インクルードを避けメモリも管理するには?)

タイトルやプレイ画面やゲームオーバーのシーンを分けましょう。
シーンは構造的にタイトル⇒プレイ画面⇒ゲームオーバー⇒タイトル...とループするので
普通に考えれば循環インクルードしやすいですね。
ということで基本方針としては

1. マネージャの.hヘッダに現在のシーンと一つ前のシーンを保持
2. マネージャの.cppで各シーンをインクルードして画面チェンジ機能の処理を作成する
3. 各シーンではマネージャの.hをインクルードして画面チェンジ機能を呼び出す

上記の構造であれば、マネージャの.hヘッダで循環は止まります、なぜか?
マネージャの.hヘッダには【画面チェンジ機能の定義だけ】があり、各シーンをインクルード必要としません。
実際の【画面チェンジ機能の処理はcppに書き】【cppで各シーンの.hヘッダをインクルードします】