Unityによるパックマンの作り方 ～完成～

GameManagerクラスの作成

GameManagerクラスでゲーム全体の管理をします。

ゲーム開始

CoroutineStart関数で迷路、パックマン、ゴースト、アイテムを初期化後、一定時間"Ready"を表示しパックマンとゴーストを動作させます。

パックマンが食べられる

パックンが食べられたときの処理はPlaceGhost関数内で各ゴーストにイベントを登録します。死亡後、アニメーションが終わるのを待ってからパックマン、ゴーストを初期化します(エサ、パワーエサはそのまま)。アニメーションが終了後の処理はAnimation Eventを使って実装します。

Animation Event

Animation Eventの詳細は下記のサイトを参照してください。

qiita.com

ゴーストが食べられる

ゴーストが食べられたときの処理もPlaceGhost関数内で各ゴーストにイベントを登録します。

エサ、パワーエサを食べる

パックマンがエサ、パワーエサを食べたときの処理はPlaceDot、PlacePowerCokie関数内でイベントを登録します。

恐慌状態の解除

FixedUpdate関数で一定時間経過したらすべてのゴーストの恐慌状態を解除するようにします。

スコアの表示

ゴーストやフルーツを食べたとき、食べた座標にスコアを表示するScorerTextを作成します。TextオブジェクトにScorerクラスをアタッチします。

Scorerクラス

public class Scorer : MonoBehaviour
{
    private Text scoreText = default;

    public void Set(int score, Vector2 pos, float span)
    {
        scoreText.text = score.ToString();
        scoreText.transform.position = pos;
        scoreText.gameObject.SetActive(true);

        StartCoroutine(CoroutineShow(span));
    }

    private void Awake()
    {
        scoreText = GetComponent<Text>();
        scoreText.gameObject.SetActive(false);
    }

    private IEnumerator CoroutineShow(float span)
    {
        yield return new WaitForSeconds(span);
        scoreText.gameObject.SetActive(false);
    }
}

GameManagerクラス

public class GameManager : MonoBehaviour
{
    [SerializeField] private Pacman pacmanPrefab = default;
    [SerializeField] private Maze[] mazePrefabs = default;
    [SerializeField] private Dot dotPrefab = default;
    [SerializeField] private PowerCokie powerCokiePrefab = default;
    [SerializeField] private Akabei akabeiPrefab = default;
    [SerializeField] private Pinky pinkyPrefab = default;
    [SerializeField] private Aosuke aosukePrefab = default;
    [SerializeField] private Guzuta guzutaPrefab = default;
    [SerializeField] private Scorer scorer = default;
    [SerializeField] private Text scoreText = default;
    //Readyの表示。
    [SerializeField] private Text readyText = default;
    //ゲームオーバーの表示。
    [SerializeField] private GameObject overPanel = default;
    [SerializeField] private GameObject allClearPanel = default;
    [SerializeField] private GameObject livesPanel = default;
    [SerializeField] private float scareSpan;
    [SerializeField] private float eatSpan;
    [SerializeField] private float eatenSpan;
    //"Ready"を表示する期間。
    [SerializeField] private float readySpan;
    [SerializeField] private float nextSpan;
    private List<AGhost> ghosts;
    private Pacman pacman;
    private Maze maze;
    private Akabei akabei;
    private Pinky pinky;
    private Aosuke aosuke;
    private Guzuta guzuta;
    private FruitsCreator fruitsCreator;
    private Fruits fruits;
    private SoundManager soundManager;
    private bool isScare;
    private float scareEndTime;
    private int mazeIndex;
    private int score;
    private int lives;
    //一度の恐慌状態で食べたゴーストの数。
    private int eatenGhost;
    //食べたエサの数。
    private int eatenDot;

    private void Start()
    {
        lives = 2;
        score = 0;

        maze = Instantiate(mazePrefabs[mazeIndex]);
        
        StartCoroutine(CoroutineStart(SetGame));
    }

    private void FixedUpdate()
    {
        if (isScare && scareEndTime < Time.fixedTime )
        {
            isScare = false;
            eatenGhost = 0;
            ghosts.ForEach(g => g.Calm());

            //BGMを再生。
            soundManager.StopBGM();
            soundManager.PlayBGM("GhostNormal", 0.6f);
        }
    }

    //Readyを一定時間表示した後、パックマン、ゴーストをActiveにする。
    private IEnumerator CoroutineStart(Action callback)
    {
        readyText.gameObject.SetActive(true);
        callback();

        yield return new WaitForSeconds(readySpan);

        readyText.gameObject.SetActive(false);

        pacman.Run();
        ghosts.ForEach(g => g.Run());

        //BGMを再生。
        soundManager.PlayBGM("GhostNormal", 0.6f);
    }
    
    private void Awake()
    {
        SetAudio();
    }

    //ステージ開始時の初期化。
    private void SetGame()
    {
        //パックマンの作成。
        pacman = Instantiate(pacmanPrefab, maze.transform);
        //パックマンの初期位置は必ず整数でないと移動中に引っかかる。
        pacman.Initialize(maze.PacmanStartPosition);
        //パックマン死亡時のイベントを登録。
        pacman.OnDead += (s, e) => CheckLives();

        //ゴーストの作成。
        PlaceGhost();
        //エサの作成。
        PlaceDot();
        //パワーエサの作成。
        PlacePowerCokie();
        //残機の更新。
        UpdateLives();

        fruitsCreator = GetComponent<FruitsCreator>();
        fruitsCreator.Initialize();

        scareEndTime = 0;
        eatenGhost = 0;
        eatenDot = 0;
    }

    //パックマンが死亡後の初期化。
    private void ResetGame()
    {
        pacman = Instantiate(pacmanPrefab, maze.transform);
        pacman.Initialize(maze.PacmanStartPosition);
        pacman.OnDead += (s, e) => CheckLives();

        ghosts.ForEach(g => Destroy(g.gameObject));
        PlaceGhost();
        UpdateLives();

        scareEndTime = 0;
        eatenGhost = 0;
    }

    private void PlaceGhost()
    {
        akabei = Instantiate(akabeiPrefab, maze.transform);
        akabei.Initialize(maze, pacman);

        pinky = Instantiate(pinkyPrefab, maze.transform);
        pinky.Initialize(maze, pacman);

        aosuke = Instantiate(aosukePrefab, maze.transform);
        aosuke.Initialize(maze, pacman, akabei);

        guzuta = Instantiate(guzutaPrefab, maze.transform);
        guzuta.Initialize(maze, pacman);

        ghosts = new List<AGhost>
        { akabei, pinky, aosuke, guzuta };

        ghosts.ForEach(g =>
        {
            //ゴーストが食べられたときの処理。
            g.OnEaten += (s, e) =>
            {
                //パックマン、ゴーストを一時停止。
                PauseAll(eatSpan);

                //食べたゴーストの数により、点数が変化する。
                var scr = g.Score * (1 << eatenGhost);
                //得点の更新。
                score += scr;
                scoreText.text = score.ToString();
                //得点を表示。
                scorer.Set(scr, g.transform.position, eatSpan);
                
                eatenGhost++;

                soundManager.PlaySE("EatGhost", 0.6f);
            };

            //ゴーストが食べたときの処理。
            g.OnEat += (s, e) =>
            {
                pacman.Dead();
                //ゴーストを停止。
                ghosts.ForEach(g2 => g2.Stop());
                isScare = false;
                lives--;

                if (fruits != null) fruits.Destroy();

                soundManager.PlaySE("Dead", 0.6f);
                soundManager.StopBGM();
            };
        });
    }

    private void PlaceDot()
    {
        var poses = maze.DotPositions;
        int all = poses.Count;
        
        poses.ForEach(p =>
        {
            var dot = Instantiate(dotPrefab, maze.transform, false);
            dot.transform.localPosition = p;

            //パックマンが食べたときの処理。
            dot.OnEaten += (s, e) =>
            {
                //得点の更新。
                var d = (Dot)s;
                score += d.Score;
                scoreText.text = score.ToString();

                eatenDot++;
                //フルーツの作成。
                CreateFruits();

                //SEの再生。
                soundManager.PlaySE("EatDot", 0.4f);

                all--;

                //エサを全部食べた。
                if (all == 0)
                {
                    //パックマン、ゴーストの停止。
                    StopAll();
                    //BGM、SEの停止。
                    soundManager.StopBGM();
                    soundManager.StopSE();
                    //迷路を点滅。
                    maze.Blinking();
                    //次のステージを開始。
                    StartCoroutine(CoroutineNext());
                }
            };
        });
    }

    private void PlacePowerCokie()
    {
        var poses = maze.PowerCokiePositions;

        poses.ForEach(p =>
        {
            var pow = Instantiate(powerCokiePrefab, maze.transform, false);
            pow.transform.localPosition = p;

            //パックマンが食べたときの処理。
            pow.OnEaten += (s, e) =>
            {
                //ゴーストを恐慌状態にする。
                isScare = true;
                scareEndTime = Time.fixedTime + scareSpan;
                ghosts.ForEach(g => g.Scare(scareSpan));

                //得点の更新。
                var pc = (PowerCokie)s;
                score += pc.Score;
                scoreText.text = score.ToString();

                eatenDot++;
                //フルーツの作成。
                CreateFruits();

                //SE、BGMの再生。
                soundManager.PlaySE("EatPowerCokie", 0.2f);
                soundManager.StopBGM();
                soundManager.PlayBGM("GhostScare", 0.4f);
            };
        });
    }

    private void PauseAll(float span)
    {
        pacman.Pause(span);
        ghosts.ForEach(g => g.Pause(span));
    }

    private void StopAll()
    {
        pacman.Stop();
        ghosts.ForEach(g => g.Stop());
        isScare = false;
    }

    private void CheckLives()
    {
        if (lives >= 0)
        {
            StartCoroutine(CoroutineStart(ResetGame));
        }
        else
        {
            overPanel.SetActive(true);
        }
    }

    private void CreateFruits()
    {
        if (fruitsCreator.HasEatenDotEnough(eatenDot))
        {
            fruits = fruitsCreator.Create(maze, mazeIndex);

            //パックマンが食べたときの処理。
            fruits.OnEaten += (s, e) =>
            {
                var f = (Fruits)s;
                //得点の更新。
                score += f.Score;
                scoreText.text = score.ToString();
                //得点を表示。
                scorer.Set(f.Score, f.transform.position, eatSpan);

                //SEを再生。
                soundManager.PlaySE("EatPowerCokie", 0.2f);
            };
        }
    }

    private void UpdateLives()
    {
        var p = livesPanel.transform;

        for (int i = 0; i < p.childCount;i++)
        {
            if (i < lives) p.GetChild(i).gameObject.SetActive(true);
            else p.GetChild(i).gameObject.SetActive(false);
        }
    }

    private void SetAudio()
    {
        soundManager = SoundManager.Instance;
        soundManager.LoadSE("EatDot", "Byu");
        soundManager.LoadSE("EatPowerCokie", "ByChance");
        soundManager.LoadSE("EatGhost", "Byuu");
        soundManager.LoadSE("Dead", "Qyurururu");
        soundManager.LoadBGM("GhostNormal", "Panic");
        soundManager.LoadBGM("GhostScare", "LFO");
        soundManager.LoadSE("GhostDead", "Obake");
    }
}

Pacmanクラス

public class Pacman : MonoBehaviour, IWarpable
{
    //死亡時のイベントを登録。
    public event EventHandler OnDead;

    private void Destroy()
    {
        Destroy(gameObject);
        OnDead(this, EventArgs.Empty);
    }
}

完成

完成したものがこちら nullsuke.github.io

ソースコードはこちら github.com

まとめ

• ゴーストの状態管理をStateパターンを用いて実装したが、if文やSwtich文を使った方が簡単だったかもしれない。今後拡張するするつもりもないし。
• 今回、お絵描きソフトで矩形を描いてそこからBoxColliderやWaypointの座標を取得するという方法を使った。かかる時間自体は手作業とたいして変わらないけれど、マップを重ねて見ながら位置を指定できるのでそれなりに便利かなと思った。
• 今回使ったマップは巣の近辺のWaypointが小数になってしまい、移動の処理がちょっと複雑になってしまった。マップを調整するか、移動方法を根本的に見直した方がよいかもしれない。
• 追跡時に対象までの最短距離を直線距離でなくA*などで求めた方がいいような気もする(処理が重くなる？）。

Unityによるパックマンの作り方 ～BGM・SEを再生する～

BGM・SEを管理する専用のクラス、SoundManagerを作成します。どこのクラスから使用されてもいいようにシングルトンにします。

SoundManagerクラス

public class SoundManager
{
    private readonly AudioSource bgmAudioSource;
    private readonly AudioSource seAudioSource;
    private readonly AudioClip[] allAudioPool;
    private readonly Dictionary<string, AudioClip> bgmPool = 
        new Dictionary<string, AudioClip>();
    private readonly Dictionary<string, AudioClip> sePool = 
        new Dictionary<string, AudioClip>();

    public static SoundManager Instance { get; } = new SoundManager();

    //BGMのAudioclipをDictionaryに追加。
    public void LoadBGM(string key, string name)
    {
        if (bgmPool.ContainsKey(key)) return;

        var audio = GetAudioClip(name);

        bgmPool.Add(key, audio);
    }

    //SEのAudioclipをDictionaryに追加。
    public void LoadSE(string key, string name)
    {
        if (sePool.ContainsKey(key)) return;

        var audio = GetAudioClip(name);

        sePool.Add(key, audio);
    }

    //BGMの再生。
    public void PlayBGM(string name, float volume = 1)
    {
        if (bgmPool[name] == null) throw new Exception("not found");

        bgmAudioSource.clip = bgmPool[name];
        bgmAudioSource.loop = true;
        bgmAudioSource.volume = Mathf.Clamp01(volume);
        bgmAudioSource.Play();
    }

    //SEの再生。
    public void PlaySE(string name, float volume = 1)
    {
        if (sePool[name] == null) throw new Exception("not found");

        volume = Mathf.Clamp01(volume);
        seAudioSource.PlayOneShot(sePool[name], volume);
    }

    //BGMの停止。
    public void StopBGM()
    {
        bgmAudioSource.Stop();
    }

    //BGMの一時停止。
    public void PauseBGM()
    {
        if (bgmAudioSource.isPlaying) bgmAudioSource.Pause();
        else bgmAudioSource.UnPause();
    }

    //SEの停止。
    public void StopSE()
    {
        seAudioSource.Stop();
    }

    private SoundManager()
    {
        allAudioPool = Resources.LoadAll<AudioClip>("Audio");

        var obj = new GameObject("SoundManager");
        bgmAudioSource = obj.AddComponent<AudioSource>();
        seAudioSource = obj.AddComponent<AudioSource>();
        UnityEngine.Object.DontDestroyOnLoad(obj);
    }

    //DictionaryからAudioClipを取得。
    private AudioClip GetAudioClip(string name)
    {
        var audio = allAudioPool.FirstOrDefault(a => a.name == name);

        if (audio == null) throw new Exception("not found");

        return audio;
    }
}

GameManagerの起動時にAudioClipを読み込みます。

GameManagerクラス

public class GameManager : MonoBehaviour
{
    private SoundManager soundManager;

    private void Awake()
    {
        SetAudio();
    }

    private void SetAudio()
    {
        soundManager = SoundManager.Instance;
        //パックマンがエサを食べたとき。
        soundManager.LoadSE("EatDot", "Byu");
        //パックマンがパワーエサを食べたとき。
        soundManager.LoadSE("EatPowerCokie", "ByChance");
        //パックマンがゴーストを食べたとき。
        soundManager.LoadSE("EatGhost", "Byuu");
        //パックマンが死んだとき。
        soundManager.LoadSE("Dead", "Qyurururu");
        //ゴーストが通常状態のとき。
        soundManager.LoadBGM("GhostNormal", "Panic");
        //ゴーストが恐慌状態のとき。
        soundManager.LoadBGM("GhostScare", "LFO");
        //ゴーストが死亡状態のとき。
        soundManager.LoadSE("GhostDead", "Obake");
    }
}

再生したい部分でPlayBGM、PlaySEを実行します。

GameManagerクラス

[SerializeField] private Text readyText = default;
private List<AGhost> ghosts;
private Pacman pacman;
private SoundManager soundManager;
private bool isScare;
private float scareEndTime;
//一度の恐慌状態で食べたゴーストの数。
private int eatenGhost;

private void FixedUpdate()
{
    if (isScare && scareEndTime < Time.fixedTime )
    {
        isScare = false;
        eatenGhost = 0;
        ghosts.ForEach(g => g.Calm());

        //BGMを再生。
        soundManager.StopBGM();
        soundManager.PlayBGM("GhostNormal", 0.6f);
    }
}

//Readyを一定時間表示した後、パックマン、ゴーストをActiveにするコルーチン。
private IEnumerator CoroutineStart(Action callback)
{
    readyText.gameObject.SetActive(true);
    callback();

    yield return new WaitForSeconds(readySpan);

    readyText.gameObject.SetActive(false);

    pacman.Run();
    ghosts.ForEach(g => g.Run());

    //BGMを再生。
    soundManager.PlayBGM("GhostNormal", 0.6f);
}

Deadクラス

public class Dead : IState
{
    private readonly Mover mover;
    private readonly Animator animator;
    private readonly SoundManager soundManager;
    
    public void SetState()
    {
        mover.SetWaypoints(nestWaypoints);
        mover.Speed = defaultSpeed * 2f;

        animator.SetBool("IsScare", false);
        animator.SetBool("IsCalmSoon", false);
        animator.SetBool("IsDead", true);

        //BGMを再生。
        soundManager.PlaySE("GhostDead", 0.2f);
    }
}

Unityによるパックマンの作り方 ～アイテムの作成～

オブジェクトの作成

16px × 16pxの画像を用意し、Pixels Per Unitを8にします。画像からSpriteを作成し、CirlceCollider2Dをアタッチします。適当にColliderの大きさを設定します。また、パックマンの当たり判定は無視しなければならないので、Layerの設定をIgnore Laycastにします。

Sprite画像

アイテムのオブジェクト

クラスの作成

エサ

Dotクラスを作成します。パックマンに食べられるのでインターフェイスIEatableを継承します。

Dotクラス

public class Dot : MonoBehaviour, IEatable
{
    public event EventHandler OnEaten;
    private static readonly int score = 10;

    public int Score { get => score; }

    public void Eaten(Pacman pacman = null)
    {
        OnEaten(this, EventArgs.Empty);
        //Destroyだと処理が重いのでとりあえず非アクティブにしておく。
        gameObject.SetActive(false);
    }

    public void Destroy()
    {
        Destroy(gameObject);
    }
}

パワーエサ

PowerCokieクラスを作成します。パックマンに食べられるのでインターフェイスIEatableを継承します。

PowerCokieクラス

public class PowerCokie : MonoBehaviour, IEatable
{
    public event EventHandler OnEaten;
    private static readonly int score = 50;

    public int Score { get => score; }

    public void Eaten(Pacman pacman = null)
    {
        OnEaten(this, EventArgs.Empty);
        gameObject.SetActive(false);
    }

    public void Destroy()
    {
        Destroy(gameObject);
    }
}

フルーツ

フルーツ毎にクラスを作成します。まずインターフェイスIEatableを継承したFruitsクラスを作成し、これを継承した各フルーツのクラスを作成します(まぁ、中身はスコアだけですが)。

Fruitsクラス

public class Fruits : MonoBehaviour, IEatable
{
    public event EventHandler OnEaten;
    protected int score;
    //表示時間。
    private readonly static int limit = 10;

    public int Score => score;

    public void Eaten(Pacman pacman = null)
    {
        OnEaten(this, EventArgs.Empty);
        Destroy(gameObject);
    }

    public void Destroy()
    {
        Destroy(gameObject);
    }

    private void Start()
    {
        StartCoroutine(CroutineAppear());
    }

    //limit秒後削除。
    private IEnumerator CroutineAppear()
    {
        yield return new WaitForSeconds(limit);
        Destroy(gameObject);
    }
}

各フルーツクラス

public class Cherry : Fruits
{
    private void Start()
    {
        score = 100;
    }
}

public class Strawberry : Fruits
{
    private void Start()
    {
        score = 300;
    }
}

public class Orange : Fruits
{
    private void Start()
    {
        score = 500;
    }
}

迷路に設置

各アイテムを迷路に設置します。各アイテムのオブジェクトにそれぞれのクラスをアタッチします。また、ゴーストのWaypointsMapの作成と同じ要領でDotMap、PowerCokieMapを作成し、エサとパワーエサの座標を取得します。

フルーツはエサを70、170個食べた時点で出現する仕様なのでちょっと大げさですが専用のクラスFruitsCreatorを作成します。

FruitsCreatorクラス

public class FruitsCreator : MonoBehaviour
{
    [SerializeField] private Fruits[] fruitsPrefabs = default;
    //フルーツ出現に必要なエサの個数。
    private readonly int[] limits = { 70, 170, int.MaxValue };
    private int limit;
    private int i;

    public void Initialize()
    {
        limit = limits[0];
        i = 0;
    }

    public bool HasEatenDotEnough(int cnt)
    {
        if (limit <= cnt)
        {
            i++;
            limit = limits[i];

            return true;
        }
        return false;
    }

    public Fruits Create(Maze maze, int mazeIndex)
    {
        var fruits = Instantiate(fruitsPrefabs[mazeIndex], maze.transform);
        //パックマンのスタート地点に出現させる。
        fruits.transform.localPosition = maze.PacmanStartPosition;

        return fruits;
    }
}

GameManagerクラスでゲーム開始時にアイテムを設置します。このときOnEatenイベントにパックマンが食べたときの処理を実装します。

アイテムの設置

public class GameManager : MonoBehaviour
{
    [SerializeField] private Dot dotPrefab = default;
    [SerializeField] private PowerCokie powerCokiePrefab = default;
    [SerializeField] private Scorer scorer = default;
    [SerializeField] private Text scoreText = default;
    [SerializeField] private float scareSpan;
    [SerializeField] private float nextSpan;
    private List<AGhost> ghosts;
    private Maze maze;
    private FruitsCreator fruitsCreator;
    private Fruits fruits;
    private SoundManager soundManager;
    private bool isScare;
    private float scareEndTime;
    private int mazeIndex;
    private int score;
    //食べたエサの数。
    private int eatenDot;

    //ゲーム開始時に実行。
    private void SetGame()
    {
        //パックマンの作成。
        pacman = Instantiate(pacmanPrefab, maze.transform);
        //パックマンの初期位置は必ず整数でないと移動中に引っかかる。
        pacman.Initialize(maze.PacmanStartPosition);
        //パックマン死亡時のイベントを登録。
        pacman.OnDead += (s, e) => CheckLives();

        //ゴーストの作成。
        PlaceGhost();
        //エサの作成。
        PlaceDot();
        //パワーエサの作成。
        PlacePowerCokie();
        //残機の更新。
        UpdateLives();

        fruitsCreator = GetComponent<FruitsCreator>();
        fruitsCreator.Initialize();

        scareEndTime = 0;
        eatenGhost = 0;
        eatenDot = 0;
    }

    private void PlaceDot()
    {
        var poses = maze.DotPositions;
        int all = poses.Count;
        
        poses.ForEach(p =>
        {
            var dot = Instantiate(dotPrefab, maze.transform, false);
            dot.transform.localPosition = p;

            //パックマンが食べたときの処理。
            dot.OnEaten += (s, e) =>
            {
                //得点の更新。
                var d = (Dot)s;
                score += d.Score;
                scoreText.text = score.ToString();

                eatenDot++;
                //フルーツの作成。
                CreateFruits();

                //SEの再生。
                soundManager.PlaySE("EatDot", 0.4f);

                all--;

                //エサを全部食べた。
                if (all == 0)
                {
                    //パックマン、ゴーストの停止。
                    StopAll();
                    //BGM、SEの停止。
                    soundManager.StopBGM();
                    soundManager.StopSE();
                    //迷路を点滅。
                    maze.Blinking();
                    //次のステージを開始。
                    StartCoroutine(CoroutineNext());
                }
            };
        });
    }

    private void PlacePowerCokie()
    {
        var poses = maze.PowerCokiePositions;

        poses.ForEach(p =>
        {
            var pow = Instantiate(powerCokiePrefab, maze.transform, false);
            pow.transform.localPosition = p;

            //パックマンが食べたときの処理。
            pow.OnEaten += (s, e) =>
            {
                //ゴーストを恐慌状態にする。
                isScare = true;
                scareEndTime = Time.fixedTime + scareSpan;
                ghosts.ForEach(g => g.Scare(scareSpan));

                //得点の更新。
                var pc = (PowerCokie)s;
                score += pc.Score;
                scoreText.text = score.ToString();

                eatenDot++;
                //フルーツの作成。
                CreateFruits();

                //SE、BGMの再生。
                soundManager.PlaySE("EatPowerCokie", 0.2f);
                soundManager.StopBGM();
                soundManager.PlayBGM("GhostScare", 0.4f);
            };
        });
    }

    private void CreateFruits()
    {
        if (fruitsCreator.HasEatenDotEnough(eatenDot))
        {
            fruits = fruitsCreator.Create(maze, mazeIndex);

            //パックマンが食べたときの処理。
            fruits.OnEaten += (s, e) =>
            {
                var f = (Fruits)s;
                //得点の更新。
                score += f.Score;
                scoreText.text = score.ToString();
                //得点の表示。
                scorer.Set(f.Score, f.transform.position, eatSpan);

                //SEを再生。
                soundManager.PlaySE("EatPowerCokie", 0.2f);
            };
        }
    }
}

Unityによるパックマンの作り方 ～ゴーストの仕様～

すべてのゴーストは待機状態から始まり、巡回→追跡→巡回を繰り返します。オリジナルでは巡回・追跡のループを重ねるごとに各状態の実行時間が変化するようですが、面倒なので今回は常に巡回を7秒、追跡を20秒としました。

各ゴーストの巡回経路

アカベイ

• 待機：なし。最初から巣の外にいます。
• 巡回：巣の右上付近を巡回。
• 追跡：パックマン自身を追跡対象とします。

  

  アカベイのWaypointsData

ピンキー

• 待機：3秒待機します。待機中上・下の移動を繰り返す。
• 巡回：巣の左上付近を巡回。
• 追跡：パックマンの移動方向の4Unit先を追跡対象とします。

  

  ピンキーのWaypointsData

アオスケ

• 待機：5秒待機します。待機中下・上の移動を繰り返す。
• 巡回：巣の左下付近を巡回。
• 追跡：パックマンの進行方向の2Unit先を点P、アカベイと点Pを結ぶベクトルをAPとしたとき、ベクトルAPの長さを2倍にしたときの点を追跡対象とします。

アオスケの追跡対象

アオスケのWaypointsData

グズタ

• 待機：7秒待機します。待機中上・下の移動を繰り返す。
• 巡回：巣の左下付近を巡回。
• 追跡：自身とパックマンの距離が8Unit以上ならパックマンを、8Unit未満のときは迷路の原点(左下)を追跡対象とします。

グズタのWaypointsData

Unityによるパックマンの作り方 ～ゴーストのアニメーション～

通常、恐慌、死亡時のアニメーションをサブステートマシンを使って作成します。すべてのアニメーションはAny Stateから遷移するようにします。

Animation ControllerのParametersに以下の変数を作成します。

• float DirX
• float DirY
• bool isScare
• bool isCalmSoom
• bool isDead

Animation Controller

遷移の条件は以下の通りです。また、Can Transition To Selfは必ずオフにしておきましょう。

通常

• Up：DirY > 0.1 & isDead == false & isScare == false
• Right：DirX > 0.1 & isDead == false & isScare == false
• Down：DirY < -0.1 & isDead == false & isScare == false
• Left：DirX < -0.1 & isDead == false & isScare == false

通常状態のTransition

恐慌

• Purple：isScare == true & isCalmSoon == false
• PurpleWhite：isScare == true & isCalmSoon == true

恐慌状態のTransition

死亡

• Up：DirY > 0.1 & isDead == true
• Right：DirX > 0.1 & isDead == true
• Down：DirY < -0.1 & isDead == true
• Left：DirX < -0.1 & isDead == true

死亡状態のTransition

Unityによるパックマンの作り方 ～ゴーストのAI～

概要

Waypointに到達するごとに次のWaypointを取得するこで経路を決定します。以下のものが必要になります。

• Waypoints：ゴーストが移動できる全座標のリスト。
• Tile：Waypoint同士のつながりを表すクラス。
• TileUtility：ゴーストの現在地からTileを取得するクラス。
• AAI：TileUtilityを使ってゴーストの現在地からTileを取得し、移動方向を決定する抽象クラス。これを継承してゴーストごとのAIを作成します。
• 各ゴーストのAI：追跡対象を取得するクラス。

処理の流れは以下の通りです。

1. TileUtilityを使ってゴーストの現在地からTileを取得します。
2. TileからAIを使って移動先のWaypointを決定します。

Waypointsの取得

ゴーストが移動できる全座標を手作業で座標を書き出してもよいのですが、迷路のColliderMapの作成と同じ要領でWaypointsMapを作成し、MazeUtilityを使いWaypointsを取得します(MazeUtilityについては下記参照)。

nullsuke.com

WaypointsMapの描画

WaypointsMap

MazeオブジェクトにWaypointsMapをセットし、ついでに迷路の幅と高さも設定します。

Mazeオブジェクト(余計なものがいろいろついてますが気にしないでください)

TileUtilityの作成

Mazeオブジェクトが読み込まれたときにCreateTiles関数でTileのリスト作成し、それをもとにTileUtilityを作成します。

Tileクラス

public class Tile
{
    public Tile Left, Right, Up, Down;
    public Vector2 Waypoint { get; private set; }
    public int X { get; private set; }
    public int Y { get; private set; }
    //行き止まりかどうか。
    public bool IsOccupied { get; set; } = true;
    //交差点かどうか。
    public bool IsIntersection { get; set; }
    //隣接しているTileの数。
    public int AdjacentCount { get; set; }
    
    public Tile(int x, int y)
    {
        X = x;
        Y = y;
        Waypoint = new Vector2(x, y);
        Left = Right = Up = Down = null;
    }
}

TileUtilityクラス

public class TileUtility
{
    private readonly List<Tile> tiles;
    private readonly int maxX;
    private readonly int maxY;
    private readonly int minX;
    private readonly int minY;

    public TileUtility(List<Tile> tiles)
    {
        this.tiles = tiles;
        maxX = tiles.Max(t => t.X);
        maxY = tiles.Max(t => t.Y);
        minX = tiles.Min(t => t.X);
        minY = tiles.Min(t => t.Y);
    }

    //現在地からTileを取得。
    public Tile GetTile(Vector2 pos)
    {
        var p = RoundAwayFromZero(pos);

        if (p.x < minX) p.x = minX;
        if (p.y < minY) p.y = minY;
        if (p.x > maxX) p.x = maxX;
        if (p.y > maxY) p.y = maxY;

        var tile = tiles.Find(t => t.Position == p);

        if (tile == null) throw new Exception(p.ToString() + " tile not found");

        return tile;
    }

    private Vector2Int RoundAwayFromZero(Vector2 v)
    {
        int x = (int)(v.x + 0.5f);
        int y = (int)(v.y + 0.5f);

        return new Vector2Int(x, y);
    }
}

CreateTiles

private List<Tile> CreateTiles(Texture2D waypointsMap)
{
    var tiles = new List<Tile>();

    for (int y = 0; y < size.y; y++)
    {
        for (int x = 0; x < size.x + 1; x++)
        {
            var tile = new Tile(x, y);
            tiles.Add(tile);
        }
    }

    //WaypointsMapからRectangleを取得。
    var wayrects = mazeUtility.GetRectangles(waypointsMap);

    //Rectangleの中心座標がWaypoint。
    tiles.ForEach(t =>
    {
        if (wayrects.Exists(w => t.Waypoint == w.Center2 / 8f))
        {
            t.IsOccupied = false;
        }
    });

    SetWarpPoint(tiles);

    //Tileの上下左右にTileがあるか精査。
    foreach (var t in tiles.Where(t => !t.IsOccupied))
    {
        var up = tiles.Find(t2 => t2.Waypoint == t.Waypoint + Vector2.up);

        if (up != null && !up.IsOccupied)
        {
            t.Up = up;
            t.AdjacentCount++;
        }

        var right = tiles.Find(t2 => t2.Waypoint == t.Waypoint + Vector2.right);

        if (right != null && !right.IsOccupied)
        {
            t.Right = right;
            t.AdjacentCount++;
        }

        var down = tiles.Find(t2 => t2.Waypoint == t.Waypoint + Vector2.down);

        if (down != null && !down.IsOccupied)
        {
            t.Down = down;
            t.AdjacentCount++;
        }

        var left = tiles.Find(t2 => t2.Waypoint == t.Waypoint + Vector2.left);

        if (left != null && !left.IsOccupied)
        {
            t.Left = left;
            t.AdjacentCount++;
        }
    }

    //3つ以上Tileが隣接していたら、交差点。
    tiles.ForEach(t =>
    {
        if (t.AdjacentCount > 2) t.IsIntersection = true;
    });

    return tiles;
}

//ワープ地点のTileを追加。
private void SetWarpPoint(List<Tile> tiles)
{
    foreach(var w in GetComponentsInChildren<WarpPoint>())
    {
        var p = w.transform.localPosition;
        var tile = new Tile((int)p.x, (int)p.y);
        tile.IsOccupied = false;
        tiles.Add(tile);
    }
}

Awake

private MazeUtility mazeUtility;

public TileUtility TileUtility { get; private set; }

private void Awake()
{
    mazeUtility = GetComponent<MazeUtility>();
    TileUtility = new TileUtility(CreateTiles(waypointsMap));
}

AAIの作成

処理の流れは以下の通りです。

• GetNextTile関数で進行方向にあるTile(NextTile)を取得します。
• NextTileが存在して、かつ交差点でない場合、そのTileの位置をWaypointとします。
• NextTileが存在せず、かつ交差点でない場合、現在のタイルから進めるTileを探して、Waypointとします。
• NextTileが存在せず、かつ交差点の場合ゴーストの状態によって方法が異なります。
  • 追跡状態：GetTarget関数で追跡対象のTileを取得し、そこまでの直線距離が最も短くなるTileの位置をWaypointとします。
  • 恐慌状態：現在のTileに隣接するTileからランダムでWaypointを決定します。
  • 帰還状態：巡回開始地点を目的地とし、そこまでの直線距離が最も短くなるTileの位置をWaypointとします。
  • 死亡状態：ゴーストの巣付近を目的地とし、そこまでの直線距離が最も短くなるTileの位置をWaypointとします。

パックマンなどの追跡対象への距離を単純な直線距離で計算しているため、場合によって遠回りしています(マヌケ)。気になる人は距離の求め方を修正するとよいと思います。

マヌケなAI

AAI抽象クラス

public abstract class AAI : MonoBehaviour
{
    protected Pacman pacman;
    protected TileUtility tileUtility;
    
    public void Initialize(Pacman pacman, TileUtility tileUtility)
    {
        this.pacman = pacman;
        this.tileUtility = tileUtility;
    }

    public Vector2 GetWaypoint(Vector2 dir, State? state = null, Vector2? tp = null)
    {
        var currentPos = (Vector2)transform.localPosition;
        var currentTile = tileUtility.GetTile(currentPos);
        var nextTile = GetNextTile(dir, currentPos);
        var waypoint = currentPos;

        //移動できないか、交差点の場合。
        if (nextTile.IsOccupied || currentTile.IsIntersection)
        {
            //移動できなくて、かつ交差点でもない場合。
            if (nextTile.IsOccupied && !currentTile.IsIntersection)
            {
                if (dir.x != 0)
                {
                    if (currentTile.Up != null) waypoint = currentTile.Up.Waypoint;
                    if (currentTile.Down != null) waypoint = currentTile.Down.Waypoint;
                    
                    if (currentTile.Up == null && currentTile.Down == null)
                    {
                        if (dir.x > 0) waypoint = currentTile.Left.Waypoint;
                        else waypoint = currentTile.Right.Waypoint;
                    }
                }

                if (dir.y != 0)
                {
                    if (currentTile.Right != null) waypoint = currentTile.Right.Waypoint;
                    if (currentTile.Left != null) waypoint = currentTile.Left.Waypoint;
                    
                    if (currentTile.Right == null && currentTile.Left == null)
                    {
                        if (dir.y > 0) waypoint = currentTile.Down.Waypoint;
                        else waypoint = currentTile.Up.Waypoint;
                    }
                }
            }

            //交差点の場合。
            if (currentTile.IsIntersection)
            {
                switch (state)
                {
                    //追跡状態のとき対象に向けて移動。
                    case State.Chase:
                        tp = GetTargetTile().Waypoint;
                        waypoint = GetWaypointAtIntersection(dir, currentTile, tp.Value);
                        break;
                    //恐慌状態のときランダムに移動。
                    case State.Scare:
                        waypoint = GetWaypointAtIntersection(dir, currentTile);
                        break;
                    //その他。
                    case null:
                        waypoint = GetWaypointAtIntersection(dir, currentTile, tp.Value);
                        break;
                    default:
                        break;
                }
            }

            return waypoint;
        }
        else //移動できて、かつ交差点でない場合。
        {
            return nextTile.Waypoint;
        }
    }

    //追跡対象のtileを取得。実装は各ゴーストでする。
    protected abstract Tile GetTargetTile();

    protected float GetSqrDistance(Vector2 a, Vector2 b)
    {
        return Mathf.Pow(a.x - b.x, 2) + Mathf.Pow(a.y - b.y, 2);
    }

    private Tile GetNextTile(Vector2 dir, Vector2 pos)
    {
        Tile nextTile = null;

        if (dir.x > 0)
        {
            nextTile = tileUtility.GetTile(pos + Vector2.right);
        }
        if (dir.x < 0)
        {
            nextTile = tileUtility.GetTile(pos + Vector2.left);
        }
        if (dir.y > 0)
        {
            nextTile = tileUtility.GetTile(pos + Vector2.up);
        }
        if (dir.y < 0)
        {
            nextTile = tileUtility.GetTile(pos + Vector2.down);
        }

        return nextTile;
    }

    //tpへの直線距離が近いwaypointを取得。
    private Vector2 GetWaypointAtIntersection(Vector2 dir, Tile currentTile, Vector2 tp)
    {
        var waypoint = currentTile.Waypoint;

        float up, right, down, left;
        up = right = down = left = Mathf.Infinity;

        if (currentTile.Up != null && !(dir.y < 0))
        {
            up = GetSqrDistance(tp, currentTile.Up.Waypoint);
        }

        if (currentTile.Right != null && !(dir.x < 0))
        {
            right = GetSqrDistance(tp, currentTile.Right.Waypoint);
        }

        if (currentTile.Down != null && !(dir.y > 0))
        {
            down = GetSqrDistance(tp, currentTile.Down.Waypoint);
        }

        if (currentTile.Left != null && !(dir.x > 0))
        {
            left = GetSqrDistance(tp, currentTile.Left.Waypoint);
        }

        var min = Mathf.Min(up, right, down, left);

        if (min == up) waypoint = currentTile.Up.Waypoint;
        else if (min == right) waypoint = currentTile.Right.Waypoint;
        else if (min == down) waypoint = currentTile.Down.Waypoint;
        else if (min == left) waypoint = currentTile.Left.Waypoint;

        if (waypoint == currentTile.Waypoint) throw new Exception("no way");

        return waypoint;
    }

    //現在のtileからランダムにwaypointを取得。
    private Vector2 GetWaypointAtIntersection(Vector2 dir, Tile currentTile)
    {
        var available = new List<Tile>();

        if (currentTile.Up != null && !(dir.y < 0))
        {
            available.Add(currentTile.Up);
        }

        if (currentTile.Right != null && !(dir.x < 0))
        {
            available.Add(currentTile.Right);
        }

        if (currentTile.Down != null && !(dir.y > 0))
        {
            available.Add(currentTile.Down);
        }

        if (currentTile.Left != null && !(dir.x > 0))
        {
            available.Add(currentTile.Left);
        }

        var m = available.Count;
        var r = UnityEngine.Random.Range(0, m);

        return available[r].Waypoint;
    }
}

各ゴーストのAIの作成

AAIを継承してゴーストごとのAIを作成します。追跡対象がいるTileを取得するGetTargetTileを実装します。

各ゴーストの追跡時の仕様については下記を参照してください。

nullsuke.com

アカベイ

public class AkabeiAI : AAI
{
    protected override Tile GetTargetTile()
    {
        return tileUtility.GetTile(pacman.transform.localPosition);
    }
}

ピンキー

public class PinkyAI : AAI
{
    protected override Tile GetTargetTile()
    {
        var targetPos = (Vector2)pacman.transform.localPosition +
            pacman.Direction * 4;
        var tile = tileUtility.GetTile(targetPos);

        return tile;
    }
}

アオスケ

public class AosukeAI : AAI
{
    private Akabei akabei;

    public void Initialize(Pacman pacman, TileUtility tileUtility,
        Akabei akabei)
    {
        this.akabei = akabei;
        base.Initialize(pacman, tileUtility);
    }

    protected override Tile GetTargetTile()
    {
        var forwardPos = (Vector2)pacman.transform.localPosition +
            pacman.Direction * 2;
        var ambushVector = forwardPos -
            (Vector2)akabei.transform.localPosition;
        var targetPos = forwardPos + ambushVector;
        var tile = tileUtility.GetTile(targetPos);

        return tile;
    }
}

グズタ

public class GuzutaAI : AAI
{
    protected override Tile GetTargetTile()
    {
        var limit = 64;
        var dis = GetSqrDistance(pacman.transform.localPosition,
            transform.localPosition);
        Vector2 targetPos = Vector2.zero;

        if (dis >= limit) targetPos = pacman.transform.localPosition;
     
        return tileUtility.GetTile(targetPos);
    }
}

Unityによるパックマンの作り方 ～ゴーストの移動～

概要

ゴーストが移動できる座標(Waypoint)のリスト(Waypoints)とWaypointに向かって移動させるMoverクラスが必要になります。MoverクラスでWaypointへの移動を繰り返すことでゴーストを移動させます。

Waypointsの設定・取得

ゴーストの状態によりWaypointsの取得の仕方が異なります。

待機・準備・巡回状態でのWaypoints

ゴーストの状態が待機・準備・巡回の場合、あらかじめWaypointsを設定しておきます。1匹のゴーストが複数のWaypointsを保持する必要があるので、ScriptableObjectを使って各状態のWaypointsを保持するGhostWaypointsDataを作成します。これらをMazeオブジェクトにセットします。ついでにスタート位置もここで設定します。

GhostWaypointsDataクラス

[CreateAssetMenu(menuName = "Scriptable/Create GhostWaypointsData")]
public class GhostWaypointsData : ScriptableObject
{
    public Vector2 Start;
    public List<Vector2> Wait;
    public List<Vector2> Init;
    public List<Vector2> Scatter;
}

アカベイのGhostWaypointsData

各ゴーストのGhostWaypointsDataをMazeオブジェクトにセットします。

各ゴーストのGhostWaypointsData

死亡状態でのWaypoints

今回使用した迷路はゴーストの巣の入り口正面のWaypointが整数にならず、追跡状態のようにＡＩで目的地まで移動させることができません。よって、あらかじめNestWaypointsを設定して、Mazeオブジェクトにセットしておきます。迷路の形にこだわらければ、巣の位置を調整してWaypointが整数になるようにしてもよいと思います。

NestWaypoints

追跡・恐慌・帰還状態でのWaypoints

追跡・恐慌・帰還状態ではAI（といってもかなりしょぼい）によって経路を決定します。ゴーストのAIについては 下記を参考にしてください。

nullsuke.com

Moverの作成

WaypointへVector2.MoveTowardsとrigid2D.MovePositionを使い移動させるクラスです。

Moverクラス

public class Mover : MonoBehaviour
{
    [SerializeField] float defaultSpeed = default;
    private Queue<Vector2> waypoints;
    private AAI ai;
    private Rigidbody2D rigid2D;
    private Vector2 waypoint;
    
    public Vector2 Direction { get; private set; }
    public float Speed { get; set; }

    public void Initialize(AAI ai)
    {
        this.ai = ai;
        Speed = defaultSpeed;
    }

    private void Awake()
    {
        rigid2D = GetComponent<Rigidbody2D>();
    }

    public void SetWaypoints(Queue<Vector2> waypoints)
    {
        this.waypoints = new Queue<Vector2>(waypoints);
    }

    //決められたルートを移動、巡回。
    public void MoveToWaypoints(bool loop = false)
    {
        if (waypoints.Count == 0) return;

        waypoint = waypoints.Peek();

        if (Vector3.Distance(transform.localPosition, waypoint) > float.Epsilon)
        {
            MoveTo(waypoint);
        }
        else
        {
            if (loop) waypoints.Enqueue(waypoints.Dequeue());
            else waypoints.Dequeue();
        }
    }

    //AIでwaypointを取得して移動。
    public void MoveToWaypoints(State state)
    {
        if (Vector3.Distance(transform.localPosition, waypoint) > float.Epsilon)
        {
            MoveTo(waypoint);
        }
        else
        {
            waypoint = ai.GetWaypoint(Direction, state);
        }
    }

    //目的地まで移動したら、callbackを実行。
    public void MoveToWaypointsThen(Vector2 tp, Action callback)
    {
        if (Vector3.Distance(transform.localPosition, waypoint) > float.Epsilon)
        {
            MoveTo(waypoint);
        }
        else
        {
            if (Vector3.Distance(transform.localPosition, tp) > float.Epsilon)
            {
                waypoint = ai.GetWaypoint(Direction, null, tp);
            }
            else callback();
        }
    }

    //決められたルートで目的地まで移動したら、callbackを実行。
    public void MoveToWaypointsThen(Action callback)
    {
        if (waypoints.Count == 0)
        {
            callback();
            return;
        }

        MoveToWaypoints();
    }

    private void MoveTo(Vector2 pos)
    {
        if (pos != (Vector2)transform.localPosition)
        {
            Direction = Vector3.Normalize(pos - (Vector2)transform.localPosition);
        }

        var wp = transform.parent.TransformPoint(pos);
        var p = Vector2.MoveTowards(transform.position, wp, Speed);
        rigid2D.MovePosition(p);
    }
}