UnityUnityメモ
ActionC#EventUnityカスタムイベントゲーム開発プログラミング

【Unity C#】カスタムイベントの作り方！EventとActionを使いこなそう

Unity
2025.02.22

1. はじめに

ゲーム開発では、あるオブジェクトの状態が変わったときに、他のオブジェクトに影響を与えるような処理を実装する場面が多くあります。例えば、「プレイヤーのHPがゼロになったらゲームオーバー画面を表示する」「敵を倒したらスコアを更新する」などのイベント処理が必要になります。こういった処理を効率的に管理するために、Unityでは イベント を活用するのが一般的です。

C#では、イベント処理を簡単に実装できる Event と Action という仕組みが用意されています。これを活用することで、スクリプト間の依存関係を減らし、コードの可読性やメンテナンス性を向上させることができます。

Unityでのイベント処理の重要性

イベント処理を適切に使うことで、次のようなメリットがあります。

① スクリプト間の依存関係を減らせる

例えば、プレイヤーのスクリプトで「敵を倒したらスコアを増やす」処理を直接書くと、スコア管理のスクリプトと強く結びついてしまいます。しかし、イベントを使えば、「敵が倒されたら OnEnemyDefeated というイベントを発火する」とだけ書いておけば、スコア管理スクリプトがそのイベントを受け取ってスコアを増やすようにできます。こうすることで、スクリプト同士の関係をゆるく保ち、後から変更しやすくなります。

② 処理の流れが明確になり、バグが減る

イベントを使わない場合、ある処理の結果として次に何が起こるのかをスクリプトの中で明示的に書く必要があります。これが複雑になると、どこで何が実行されるのか分かりにくくなり、バグの原因になりやすいです。しかし、イベントを使うと「このタイミングでイベントが発火する」という形で処理の流れが整理され、可読性が向上します。

③ ゲームの拡張が簡単になる

例えば、「敵を倒したときにスコアを増やす」だけでなく、「エフェクトを出す」「音を鳴らす」「UIを更新する」などの処理を追加したい場合、イベントを使っていれば新しい処理を簡単に追加できます。イベントを発火させるだけで、他のスクリプトで自由に対応できるため、拡張性が高くなります。

C#のEventとActionを活用するメリット

Unityでは、C#の Event と Action を使ってイベント処理を簡単に実装できます。これには次のようなメリットがあります。

① コードがスッキリする

if 文や switch 文で条件分岐を増やして処理を追加するのではなく、イベントを登録するだけで処理を追加できるため、コードの見通しが良くなります。

② 柔軟にカスタマイズできる

イベントリスナー（イベントを受け取る側）を自由に設定できるため、処理の追加・削除が簡単にできます。特に Action を使うと、イベントの型を気にせず簡単にコールバック処理を登録できます。

③ パフォーマンス向上にもつながる

不要になったイベントリスナーを適切に解除すれば、無駄な処理を減らすことができます。これにより、ゲームのパフォーマンスを最適化することができます。

このように、Unityでのイベント処理はゲームの管理をシンプルにし、拡張性を高める重要な要素です。次の章では、具体的に Event と Action の基本的な使い方について解説していきます。



2. EventとActionとは？

Unityでイベント処理を実装するには、C#の Event（イベント）と Action（アクション）を活用するのが一般的です。どちらも特定のタイミングで処理を実行するための仕組みですが、それぞれ特徴が異なります。ここでは、それぞれの基本的な仕組みと、Unityでどのように使われるのかを解説していきます。

C#のEventとActionの基本的な説明

1. Event（イベント）とは？

Event は、特定の出来事が発生したときに通知を送る仕組みです。たとえば、プレイヤーがダメージを受けたときや、アイテムを拾ったときに他のオブジェクトへ通知を送るのに使われます。

基本の構文

public event Action OnPlayerDamaged;

この OnPlayerDamaged は、プレイヤーがダメージを受けたときに発生するイベントです。
イベントは 発火（Invoke） しない限り実行されません。

if (OnPlayerDamaged != null)
{
    OnPlayerDamaged.Invoke();
}

このように Invoke() を呼ぶことで、登録されている処理が実行されます。

✅ Eventのポイント

  • event キーワードを使うことで、イベントの発火元以外で Invoke() できなくなる（安全性向上）
  • 複数のリスナー（受け取る側）を登録可能
  • += でイベントに処理を追加、-= で解除
  • 登録された関数を実行するだけなので高速

2. Action（アクション）とは？

Action は、メソッドを代入できる デリゲート型 の変数です。
イベントと似ていますが、event 修飾子が不要なので よりシンプルに使える という特徴があります。

基本の構文

public Action OnGameOver;

こちらも Invoke() を使って実行できます。

OnGameOver?.Invoke();

?.Invoke() のように書くことで、登録されている関数がないときに null 参照エラーを防ぐことができます。

✅ Actionのポイント

  • event をつけなくても使える（柔軟性が高い）
  • デリゲートと同じように引数を渡せる
  • 使い方がシンプルなので、小規模なイベント処理に向いている

EventとActionの違い

比較項目EventAction
event キーワード必須不要
外部からの Invoke()不可可能
引数の受け渡しEventHandler<T> で対応可能
主な用途明示的なイベント柔軟なコールバック
  • 安全にイベントを管理したいなら Event
  • シンプルなコールバックなら Action



Unityにおけるイベント処理の仕組み

Unityでは、ゲームオブジェクトがさまざまなイベントを発生させる場面が多くあります。例えば：

✅ プレイヤーがダメージを受けたとき
→ HPバーのUIを更新する

✅ 敵が倒されたとき
→ スコアを増やし、新しい敵をスポーンさせる

こうした処理を EventやActionで実装することで、スクリプトをシンプルに管理できる ようになります。

Unityでのイベント処理の流れ

  1. イベントを定義（event や Action を使う）
  2. イベントリスナー（受け取る側）を登録（+= を使う）
  3. イベントを発火（Invoke() を呼び出す）
  4. イベントリスナーを解除（-= を使う）

例えば、プレイヤーがダメージを受けたときにHPバーを更新する処理は、次のように書けます。

① イベントを定義

public event Action<int> OnPlayerDamaged; // ダメージ量を引数で渡せる

② イベントリスナーを登録

void Start() 
{
    player.OnPlayerDamaged += UpdateHPBar;
}

void UpdateHPBar(int damage) 
{
    hpBar.fillAmount -= damage / 100f;
}

③ イベントを発火

void TakeDamage(int damage)
{
    OnPlayerDamaged?.Invoke(damage);
}

④ イベントリスナーを解除

void OnDestroy() 
{
    player.OnPlayerDamaged -= UpdateHPBar;
}

このようにイベントを活用することで、スクリプト同士の結びつきを減らし、柔軟なゲームロジックを作ることができます。

まとめ

  • Event はイベント管理が必要な場面で活用する（明示的に定義し、安全に管理）
  • Action はシンプルなコールバック処理に便利（コードが短く、直感的）
  • Unityのイベント処理では「イベント定義 → リスナー登録 → 発火 → 解除」が基本

次のステップでは、実際にEventとActionを使ってカスタムイベントを作る方法 を解説していきます！



3. Eventを使ったカスタムイベントの実装

ここでは、C#の Event を使って、カスタムイベントを実装する方法を解説します。特に、プレイヤーのHPがゼロになったときにイベントを発火し、ゲームオーバー処理を実行する 例を用いて説明します。

Event の宣言方法と使用例

C#の Event は event キーワードを使って宣言します。基本の書き方は次の通りです。

public event Action OnGameOver;

この OnGameOver というイベントは、ゲームオーバー時に発火するイベントです。Action を使うことで、イベントリスナーをシンプルに追加できます。

もし、イベントで 引数 を渡したい場合は、以下のように Action<T> を使います。

public event Action<int> OnPlayerDamaged;

この場合、int 型の引数（ダメージ量）をイベント発火時に渡せるようになります。

登録・解除の方法（+= と -= の使い方）

イベントは リスナー（処理を受け取る関数）を登録することで利用可能 になります。

✅ イベントの登録

イベントリスナーを登録するには += を使います。

void Start()
{
    OnGameOver += ShowGameOverScreen;
}

void ShowGameOverScreen()
{
    Debug.Log("ゲームオーバー！画面を表示");
}

この場合、OnGameOver イベントが発火すると ShowGameOverScreen() が呼ばれます。

✅ イベントの解除

イベントリスナーを解除するには -= を使います。OnDestroy() で解除するのが一般的です。

void OnDestroy()
{
    OnGameOver -= ShowGameOverScreen;
}

イベントリスナーの解除を忘れると、ゲームオブジェクトが破棄された後もイベントが残り続け、メモリリークの原因 になるので注意しましょう。



サンプルコード：プレイヤーのHPがゼロになったときにイベントを発火

ここでは、プレイヤーのHPがゼロになったときに OnGameOver イベントを発火させるコードを作成します。

① プレイヤースクリプト

プレイヤーのスクリプト PlayerHealth.cs を作成し、HPがゼロになったら OnGameOver を発火させます。

using System;
using UnityEngine;

public class PlayerHealth : MonoBehaviour
{
    public int maxHealth = 100;
    private int currentHealth;

    // ゲームオーバー時に発火するイベント
    public event Action OnGameOver;

    void Start()
    {
        currentHealth = maxHealth;
    }

    // ダメージを受ける処理
    public void TakeDamage(int damage)
    {
        currentHealth -= damage;
        Debug.Log($"ダメージを受けた！現在のHP: {currentHealth}");

        if (currentHealth <= 0)
        {
            currentHealth = 0;
            Debug.Log("HPがゼロになった！");
            OnGameOver?.Invoke(); // ゲームオーバーイベントを発火
        }
    }
}

✅ ポイント

  • OnGameOver は プレイヤーのHPがゼロになったときに発火するイベント 。
  • ?.Invoke() を使うことで、イベントリスナーが登録されていないときに null 参照エラーを防げる。

② ゲームオーバー処理スクリプト

次に、GameManager.cs を作成し、OnGameOver を受け取ってゲームオーバー画面を表示する処理を追加します。

using UnityEngine;

public class GameManager : MonoBehaviour
{
    public PlayerHealth player;

    void Start()
    {
        // プレイヤーのOnGameOverイベントを監視
        player.OnGameOver += ShowGameOverScreen;
    }

    void ShowGameOverScreen()
    {
        Debug.Log("ゲームオーバー画面を表示！");
        // ここでゲームオーバーUIを表示する処理を追加
    }

    void OnDestroy()
    {
        // メモリリークを防ぐためにイベントリスナーを解除
        player.OnGameOver -= ShowGameOverScreen;
    }
}

✅ ポイント

  • player.OnGameOver += ShowGameOverScreen; で イベントを登録 。
  • ShowGameOverScreen() が イベント発火時に実行される処理 。
  • OnDestroy() で -= して、不要なイベントリスナーを解除。

③ 実行して動作を確認

  1. ヒエラルキー（Hierarchy）ウィンドウで PlayerHealth オブジェクトを作成。
  2. PlayerHealth.cs を PlayerHealth オブジェクトにアタッチ。
  3. GameManager オブジェクトを作成し、GameManager.cs をアタッチ。
  4. GameManager の player に PlayerHealth オブジェクトを設定。
  5. スクリプトの TakeDamage(int damage) をテストする。
void Update()
{
    if (Input.GetKeyDown(KeyCode.Space))
    {
        TakeDamage(50);
    }
}

このコードを PlayerHealth.cs に追加し、ゲームを実行して Space キーを押すと HPが減少 し、ゼロになったら ゲームオーバーイベントが発火する のを確認できます。

まとめ

✅ Eventの使い方

  1. イベントを宣言
  2. リスナー（処理）を登録
  3. 必要なタイミングで発火
  4. 不要になったら解除

✅ Eventを使うメリット

  • スクリプト間の結びつきを減らせる
  • 拡張性が高く、あとから処理を追加しやすい
  • 可読性が向上し、バグを減らせる

次のステップでは、Actionを使ったカスタムイベントの実装方法 について解説していきます！



4. Actionを使ったカスタムイベントの実装

前のセクションでは event を使ったカスタムイベントの実装方法を解説しました。ここでは、よりシンプルにイベント処理を行う Action を使った方法を紹介します。

Action の基本的な使い方

Action は C#のデリゲート型の1つ で、特定の処理（メソッド）を格納し、必要なタイミングで実行することができます。

基本的な宣言方法

public Action onButtonClick;

この onButtonClick は、ボタンがクリックされたときに実行される処理を登録できる Action です。

イベントを発火（実行）する方法

onButtonClick?.Invoke();

?.Invoke() を使うことで、onButtonClick に何も登録されていないときに null 参照エラーを防ぐことができます。

Action を使うメリット

① コードが簡潔になる

  • event を使う場合と比べて、よりシンプルにイベント処理を記述 できる。
  • += や -= をそのまま使えるため、型の定義が不要 。

② 柔軟なコールバック処理が可能

  • Action<T> を使うことで、引数付きの処理を簡単に登録 できる。
  • メソッド名なしでラムダ式を直接登録 することもできる。



簡単なサンプルコード：ボタンをクリックしたら特定の処理を呼び出す

① UIボタンに Action を登録する

ここでは、Action を使ってボタンがクリックされたときに処理を実行する方法を説明します。

まずは、ButtonManager.cs というスクリプトを作成します。

using System;
using UnityEngine;
using UnityEngine.UI;

public class ButtonManager : MonoBehaviour
{
    public Button myButton; // ヒエラルキーにあるUIボタンをアタッチする
    public Action onButtonClick; // ボタンがクリックされたときのAction

    void Start()
    {
        // ボタンがクリックされたらActionを実行
        myButton.onClick.AddListener(() => onButtonClick?.Invoke());
    }

    public void SetButtonAction(Action action)
    {
        onButtonClick = action; // ボタンの処理を設定
    }
}

✅ ポイント

  • onButtonClick?.Invoke(); で、登録された処理があれば実行。
  • SetButtonAction(Action action) で外部からボタンの処理を登録可能。
  • myButton.onClick.AddListener() で UnityのボタンとActionを連携 。

② 他のスクリプトから Action を登録する

次に、ボタンが押されたときに スコアを増やす処理 を登録するスクリプトを作ります。

using UnityEngine;

public class GameController : MonoBehaviour
{
    public ButtonManager buttonManager;
    private int score = 0;

    void Start()
    {
        // ボタンが押されたらスコアを増やす処理を登録
        buttonManager.SetButtonAction(() => IncreaseScore());
    }

    void IncreaseScore()
    {
        score += 10;
        Debug.Log($"スコア: {score}");
    }
}

✅ ポイント

  • buttonManager.SetButtonAction(() => IncreaseScore()); でボタンの処理を設定。
  • IncreaseScore() が呼ばれるとスコアが増える。

③ 実行して動作を確認

  1. ヒエラルキーで ButtonManager オブジェクトを作成
  2. UIの Button を作成し、ButtonManager の myButton に設定
  3. GameController オブジェクトを作成
  4. GameController の buttonManager に ButtonManager オブジェクトを設定
  5. ゲームを実行し、ボタンをクリックするとスコアが増加する

まとめ

✅ Action の使い方

  1. Action を宣言
  2. 必要な処理を登録
  3. Invoke() で発火
  4. 必要に応じてリスナーを変更可能

✅ Action のメリット

  • 簡単なイベント処理に最適
  • コードがシンプルで可読性が高い
  • 引数付きの処理を柔軟に登録可能

DOTweenを使うと、アニメーションが完了したときにActionを使って次の処理を呼び出す ことができます。例えば、ボタンを押したときにアニメーションを再生し、完了後に次のイベントを実行することが可能です。
→ もっと簡単にActionを活用したアニメーション制御をしたい場合は、DOTween Proを活用すると便利です。

次のステップでは EventとActionの使い分け について詳しく解説していきます！



5. EventとActionの使い分け

C#の Event と Action は、どちらもイベント処理に使われますが、用途によって適切な選択が重要です。
ここでは、それぞれの使いどころを整理し、具体的なシナリオと実装例を紹介します。

どちらを使うべきか？

✅ Action を使うべき場面

  • シンプルなイベント処理（例：ボタンのクリック、スコアの更新）
  • 直接 Invoke() で呼び出す処理
  • += -= で自由に登録・解除を行いたい場合

✅ Event を使うべき場面

  • 複数のスクリプトからイベントを監視する場合（例：ゲームの状態管理、UIの更新）
  • イベントの発火を 特定のクラスだけに制限したい 場合（event をつけることで Invoke() を外部から実行できなくなる）
  • 明示的なイベント管理が必要な場合
ActionEvent
柔軟性高い（どこでも Invoke() 可能）低め（Invoke() は定義クラス内のみ）
安全性Invoke() できるのでバグが発生しやすいevent により外部からの発火を防げる
コードの簡潔さ短く書ける明示的なイベント管理ができる
適した用途UIのクリック、スコア更新ゲーム状態管理、オブジェクト間の通信

具体的な使用シナリオ

① スコアの更新（Actionを使用）

スコアの加算処理は単純なイベントなので、Action を使うのが適しています。

スコア管理スクリプト（ScoreManager.cs）

using System;
using UnityEngine;

public class ScoreManager : MonoBehaviour
{
    public int score = 0;
    public Action<int> onScoreUpdated; // スコアが更新されたら発火するAction

    public void AddScore(int points)
    {
        score += points;
        Debug.Log($"スコア: {score}");
        onScoreUpdated?.Invoke(score); // スコア更新イベントを発火
    }
}

UIスクリプト（ScoreUI.cs）

using UnityEngine;
using UnityEngine.UI;

public class ScoreUI : MonoBehaviour
{
    public ScoreManager scoreManager;
    public Text scoreText;

    void Start()
    {
        scoreManager.onScoreUpdated += UpdateScoreUI;
    }

    void UpdateScoreUI(int newScore)
    {
        scoreText.text = $"スコア: {newScore}";
    }

    void OnDestroy()
    {
        scoreManager.onScoreUpdated -= UpdateScoreUI; // メモリリーク防止
    }
}

✅ Actionが適している理由

  • Invoke() を直接実行できるので処理がシンプル。
  • スコア更新の処理は、特定のクラスだけで管理すれば十分。
  • event をつける必要がなく、外部から自由に登録可能。



② 敵のスポーン管理（Eventを使用）

敵のスポーン処理は複数のオブジェクト（スコア管理、ゲーム管理、UI更新）が関わるため、安全性の高い Event を使う のが適しています。

敵のスポーン管理スクリプト（EnemySpawner.cs）

using System;
using UnityEngine;

public class EnemySpawner : MonoBehaviour
{
    public event Action OnEnemySpawned; // 敵がスポーンしたときに発火

    public void SpawnEnemy()
    {
        Debug.Log("敵がスポーンした！");
        OnEnemySpawned?.Invoke(); // スポーン時にイベント発火
    }
}

スコア管理スクリプト（ScoreManager.cs）

using UnityEngine;

public class ScoreManager : MonoBehaviour
{
    public EnemySpawner enemySpawner;
    private int enemyCount = 0;

    void Start()
    {
        enemySpawner.OnEnemySpawned += IncreaseEnemyCount;
    }

    void IncreaseEnemyCount()
    {
        enemyCount++;
        Debug.Log($"敵の数: {enemyCount}");
    }

    void OnDestroy()
    {
        enemySpawner.OnEnemySpawned -= IncreaseEnemyCount;
    }
}

UIスクリプト（EnemyUI.cs）

using UnityEngine;
using UnityEngine.UI;

public class EnemyUI : MonoBehaviour
{
    public EnemySpawner enemySpawner;
    public Text enemyText;
    private int enemyCount = 0;

    void Start()
    {
        enemySpawner.OnEnemySpawned += UpdateEnemyUI;
    }

    void UpdateEnemyUI()
    {
        enemyCount++;
        enemyText.text = $"敵の数: {enemyCount}";
    }

    void OnDestroy()
    {
        enemySpawner.OnEnemySpawned -= UpdateEnemyUI;
    }
}

✅ Eventが適している理由

  • OnEnemySpawned は EnemySpawner クラスだけが Invoke() できる（安全性が高い）。
  • スコア管理やUI管理がこのイベントを監視できる ので、拡張性が高い。
  • event を使うことで、間違って他のクラスから Invoke() されるのを防げる。

まとめ

🔹 Action を使うべき場面

  • 単純なコールバック処理（UIのボタンイベント、スコア更新など）
  • メソッドの代わりに処理を登録する用途
  • += -= を自由に使いたい場合（外部からInvoke可能）

🔹 Event を使うべき場面

  • 複数のスクリプトでイベントを監視する必要がある（敵のスポーン管理、ゲームの状態管理など）
  • イベントの発火を特定のクラス内に限定したい（誤って外部から Invoke() されるのを防ぐ）
シチュエーションActionEvent
スコアの更新✅ 適している❌ 不要
UIのボタン処理✅ 適している❌ 不要
敵のスポーン❌ 不向き✅ 適している
ゲームの状態管理❌ 不向き✅ 適している

ここまでで、Event と Action の使い方と使い分けを理解しました。
次のステップでは、実際にカスタムイベントを活用して、ゲームシステムを作成する 方法を解説していきます！



6. 実践！カスタムイベントを活用したゲームシステム

ここでは、これまで学んだ Event と Action を使って シンプルなゲームシステムにカスタムイベントを実装 してみます。
具体的には、プレイヤーがダメージを受けてHPがゼロになったらゲームオーバーになる処理 を作成します。

ゲームの仕様

  • プレイヤーがダメージを受けるとHPが減る。
  • HPがゼロになったら ゲームオーバーイベントを発火 する。
  • UIにHPを表示し、HPがゼロになったらゲームオーバー画面を表示する。

① プレイヤーのHP管理（PlayerHealth.cs）

まず、プレイヤーのHPを管理し、HPがゼロになったら OnGameOver イベントを発火するスクリプトを作成します。

using System;
using UnityEngine;

public class PlayerHealth : MonoBehaviour
{
    public int maxHealth = 100;
    private int currentHealth;

    public event Action OnGameOver; // HPがゼロになったら発火するイベント
    public Action<int> OnHealthChanged; // HPが変化したら通知するAction

    void Start()
    {
        currentHealth = maxHealth;
        OnHealthChanged?.Invoke(currentHealth); // 初期HPをUIに通知
    }

    public void TakeDamage(int damage)
    {
        currentHealth -= damage;
        currentHealth = Mathf.Max(0, currentHealth); // HPが負の値にならないようにする

        Debug.Log($"ダメージを受けた！現在のHP: {currentHealth}");
        OnHealthChanged?.Invoke(currentHealth); // HP変更イベントを発火

        if (currentHealth <= 0)
        {
            Debug.Log("HPがゼロになった！ゲームオーバー");
            OnGameOver?.Invoke(); // ゲームオーバーイベントを発火
        }
    }
}

✅ ポイント

  • OnGameOver（event Action）を使ってゲームオーバー時にイベントを発火。
  • OnHealthChanged（Action<int>）を使ってHPの変化をUIに通知。

② HPのUIを更新する（HealthUI.cs）

プレイヤーのHPを画面上に表示するスクリプトを作成します。

using UnityEngine;
using UnityEngine.UI;

public class HealthUI : MonoBehaviour
{
    public PlayerHealth playerHealth;
    public Text healthText;

    void Start()
    {
        playerHealth.OnHealthChanged += UpdateHealthUI;
    }

    void UpdateHealthUI(int currentHealth)
    {
        healthText.text = $"HP: {currentHealth}";
    }

    void OnDestroy()
    {
        playerHealth.OnHealthChanged -= UpdateHealthUI; // メモリリーク防止
    }
}

✅ ポイント

  • OnHealthChanged を利用して、HPの変化をリアルタイムでUIに反映。



③ ゲームオーバー処理（GameManager.cs）

ゲームオーバーイベントが発火したら、UIに「ゲームオーバー」を表示するスクリプトを作成します。

using UnityEngine;
using UnityEngine.UI;

public class GameManager : MonoBehaviour
{
    public PlayerHealth playerHealth;
    public GameObject gameOverPanel;

    void Start()
    {
        playerHealth.OnGameOver += ShowGameOverScreen;
        gameOverPanel.SetActive(false); // 初期状態では非表示
    }

    void ShowGameOverScreen()
    {
        Debug.Log("ゲームオーバー画面を表示！");
        gameOverPanel.SetActive(true);
    }

    void OnDestroy()
    {
        playerHealth.OnGameOver -= ShowGameOverScreen; // イベントリスナー解除
    }
}

✅ ポイント

  • OnGameOver を使って、ゲームオーバー時に ShowGameOverScreen() を実行。
  • ゲームオーバーパネルを 非表示 → 表示 に切り替える。

④ ダメージテスト用スクリプト（DamageTester.cs）

テスト用に、スペースキーを押すとダメージを受ける処理 を作成します。

using UnityEngine;

public class DamageTester : MonoBehaviour
{
    public PlayerHealth playerHealth;

    void Update()
    {
        if (Input.GetKeyDown(KeyCode.Space))
        {
            playerHealth.TakeDamage(20); // 20ダメージを受ける
        }
    }
}

✅ ポイント

  • Space キーを押すと TakeDamage(20) が呼ばれる。
  • HPが減り、0になったら OnGameOver が発火。

⑤ ゲームオブジェクトの設定

1. ヒエラルキーにオブジェクトを配置

  1. Player オブジェクトを作成
    • PlayerHealth.cs をアタッチ
  2. GameManager オブジェクトを作成
    • GameManager.cs をアタッチ
    • playerHealth に Player をセット
  3. HealthUI オブジェクトを作成
    • HealthUI.cs をアタッチ
    • playerHealth に Player をセット
    • Text UI（HP表示用）を作成し、スクリプトに設定
  4. GameOverPanel オブジェクトを作成
    • Canvas 内に Panel を作り、ゲームオーバー画面用のUIを作成
    • GameManager.cs の gameOverPanel に設定
  5. DamageTester オブジェクトを作成
    • DamageTester.cs をアタッチ
    • playerHealth に Player をセット

⑥ 実行して動作確認

  1. ゲームを開始する
  2. スペースキーを押すごとにHPが減る
  3. HPがゼロになると「ゲームオーバー」画面が表示される
  4. HPのUIがリアルタイムで更新される

まとめ

✅ 今回の実装のポイント

  • Action<int> を使って HPの変更をUIに通知
  • Event を使って ゲームオーバー処理を一元管理
  • イベントを適切に解除 してメモリリークを防ぐ

✅ イベントを使うメリット

  • スクリプト間の依存を減らし、管理しやすい
  • 新しい処理を簡単に追加できる
  • ゲームシステムの拡張が容易になる

Corgi Engineを使えば、この記事で紹介したようなプレイヤーのHP管理やゲームオーバー処理も簡単に実装できます！ このアセットには イベント駆動型のシステム が組み込まれており、スクリプトを書かなくても ダメージ判定・HP管理・ジャンプ・移動などの基本機能がすぐに使える ので、すぐにゲーム制作を始めたい方にはピッタリです！ 👉 Corgi Engine – 2D + 2.5D Platformer

これで Event と Action を活用したゲームシステムが作れるようになりました！



7. まとめ

Unityのゲーム開発において、Event と Action を活用することで、コードの可読性と管理のしやすさが大幅に向上 します。

特に、ゲーム内のオブジェクト間で発生するイベントを適切に管理する ことで、以下のようなメリットがあります。

✅ スクリプト間の依存を減らし、コードを整理できる
✅ 処理の流れが明確になり、バグを減らせる
✅ 新しい機能を追加しやすく、ゲームの拡張が容易になる

これまでに紹介した ゲームオーバー処理の実装 のように、Event と Action を活用すると、シンプルで再利用可能なコード を書くことができます。

今後の開発に役立つ応用例

Event と Action は、ゲームのあらゆる場面で活用できます。ここでは、さらに発展的な応用例を紹介します。

1️⃣ プレイヤーのアクションに応じた処理

プレイヤーが特定のアクション（ジャンプ、攻撃、アイテム取得など）を実行したときに、それに応じたイベントを発火することで、ゲームの拡張が容易になります。

例：プレイヤーのジャンプイベント

public event Action OnPlayerJump;

void Jump()
{
    if (OnPlayerJump != null)
    {
        OnPlayerJump.Invoke();
    }
}

これを利用して、ジャンプ時にエフェクトを出す、サウンドを再生するなどの処理を別のスクリプトで管理 できるようになります。

2️⃣ UI の更新

Action<T> を使って スコアやHPの変化に応じたUI更新 を簡単に実装できます。

例：スコアが更新されたときにUIを変更

public Action<int> OnScoreUpdated;

void AddScore(int points)
{
    score += points;
    OnScoreUpdated?.Invoke(score);
}

UI側では、イベントをリスナーとして登録することで、スコアが変わるたびに自動で更新 されます。

3️⃣ 敵の出現やゲームの進行

敵のスポーン管理や、ウェーブ制のゲームでは Event を活用することで処理を分離し、柔軟に管理 できます。

例：敵を倒したら次のウェーブを開始

public event Action OnEnemyDefeated;

void EnemyDefeated()
{
    OnEnemyDefeated?.Invoke();
}

これを WaveManager などのクラスで監視することで、敵がすべて倒されたときに次のウェーブを自動で開始 することができます。



まとめ：EventとActionの正しい使い方を習得しよう！

Unityで Event と Action を適切に使うことで、コードの見通しが良くなり、開発効率が向上します。

🎯 シンプルな処理は Action を使い、複雑な管理が必要な場面では Event を活用するのがベスト！

今後の開発では、

  • プレイヤーのアクション に応じた処理
  • UIのリアルタイム更新
  • 敵の出現やゲーム進行の管理

など、さまざまな場面で Event と Action を活用してみましょう！ 🚀



よくある質問（FAQ）

Q
EventとActionはどのように使い分ければいいですか？
A

簡単なコールバックならAction、複雑なイベント管理が必要ならEventを使うのがベストです。

Q
イベントの解除を忘れるとどうなりますか？
A

メモリリークの原因になり、不要なイベントが発火し続けることがあります。

Q
UnityのUIボタンとEvent/Actionはどのように連携できますか？
A

Button.onClick.AddListener で Action を登録すると、簡単に処理を追加できます。

Unityでリフレクションを活用！柔軟で拡張性の高いスクリプトを作る方法
Unityのリフレクションを活用して、柔軟で拡張性の高いスクリプトを作る方法を解説！動的にメソッドやプロパティを操作するテクニックを学び、よりスマートなゲーム開発を目指しましょう。
cbagames.jp
Unity初心者必見！Asset Storeで手に入るゲーム制作が楽になるおすすめアセット
Unity Asset Storeで手に入るゲーム制作が楽になるおすすめアセットを厳選紹介！ゲーム制作を効率化し、クオリティをアップさせる便利なツールやテンプレートなどを紹介！
cbagames.jp

関連記事:

Unityのスクリプト設計を改善！SOLID原則で整理する方法【Unity初心者向け】2Dブロック崩しゲームの作り方を解説！【Unity入門】2Dシューティングゲームを簡単に作る手順を解説【Unity】ツムツム風パズルゲームを作ろう！初心者向け完全ガイドUnityのシリアライズ完全ガイド！データの保存・読み込みを自由自在に【実践】UnityでJSONデータ管理！セーブ＆ロードを最適化する方法【Unity】2Dタワーディフェンスゲームの作り方②！武器配置と弾の発射を実装Unityでオブジェクトプールを実装する方法と最適化ポイントUnity初心者が最初に作るべきゲーム5選！楽しく学べるステップバイステップガイド【実践】UnityでRPGのスキルシステムを作る！ステートマシンで簡単管理
タイトルとURLをコピーしました