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

IStateを継承したクラスで、ゴーストの状態の遷移と、そのときの行動を処理します。Dictionary<State, IState>とenum Stateで各stateを登録・参照し、Mover、Animatorで移動、アニメーションを行います。

状態とそのときの行動

移動に関しては下記を参照してください。

nullsuke.com

アニメーションに関しては下記を参照してください。

nullsuke.com

IStateインターフェイス

public interface IState
{
    //パックマンに接触したときの処理を登録。
    event EventHandler OnTouch;
    //毎フレーム実行する処理(移動、アニメーション)
    IState Excute();
    //恐慌状態になったときの処理。
    IState Frighten(float span);
    //恐慌状態が終わったときの処理。
    IState Calm();
    //パックマンに接触したときにOnTouchイベントを実行。
    IState Eaten();
    //ワープしたときの処理。
    void Warp(Vector2 pos, float span);
    //アニメーションの処理。
    void Animate();
}

enum State

//待機、準備、巡回、追跡、恐慌、帰還、死亡
public enum State { Wait, Init, Scatter, Chase, Scare, Return, Dead };

Waitクラス

public class Wait : IState
{
    public event EventHandler OnTouch;
    private readonly Dictionary<State, IState> states;
    private readonly Queue<Vector2> waypoints;
    private readonly Mover mover;
    private readonly Animator animator;
    //待機期間。
    private readonly float span;
    //待機終了時間。
    private float limitTime;

    public Wait(Mover mover, Dictionary<State, IState> states, 
        Animator animator, Queue<Vector2> waypoints, float span)
    {
        this.mover = mover;
        this.states = states;
        this.animator = animator;
        this.waypoints = waypoints;
        this.span = span;
        mover.SetWaypoints(waypoints);

        states.Add(State.Wait, this);
    }

    //一定時間巣で待機した後、準備状態になる。
    public IState Excute()
    {
        if (limitTime < Time.fixedTime)
        {
            var next = states[State.Init] as Init;
            next.SetState();

            return next;
        }

        mover.MoveToWaypoints(true);

        return this;
    }

    public void SetState()
    {
        limitTime = Time.fixedTime + span;
        mover.SetWaypoints(waypoints);
    }

    public IState Frighten(float scareSpan)
    {
        var next = states[State.Scare] as Scare;
        next.SetState(this, scareSpan);

        return next;
    }

    public IState Calm()
    {
        return this;
    }

    //アカベイだけは待機中も巣の外にいるので食べられる可能性がある。
    public IState Eaten()
    {
        OnTouch(this, EventArgs.Empty);

        return this;
    }

    //待機中ワープは絶対しない。
    public void Warp(Vector2 pos, float warpSpan)
    {
        throw new System.NotImplementedException();
    }

    public void Animate()
    {
        animator.SetFloat("DirX", mover.Direction.x);
        animator.SetFloat("DirY", mover.Direction.y);
    }
}

Initクラス

public class Init : IState
{
    public event EventHandler OnTouch;
    private readonly Dictionary<State, IState> states;
    private readonly Queue<Vector2> waypoints;
    private readonly Mover mover;
    private readonly Animator animator;

    public Init(Mover mover, Dictionary<State, IState> states,
        Animator animator, Queue<Vector2> waypoints)
    {
        this.mover = mover;
        this.states = states;
        this.animator = animator;
        this.waypoints = waypoints;

        states.Add(State.Init, this);
    }

    //巡回の最初のWaypointへ移動し、到着したら巡回状態になる。
    public IState Excute()
    {
        IState next = this;

        mover.MoveToWaypointsThen(() =>
        {
            var scatter = states[State.Scatter] as Scatter;
            scatter.SetState();

            next = scatter;
        });

        return next;
    }

    public void SetState()
    {
        mover.SetWaypoints(waypoints);
    }

    public IState Frighten(float scareSpan)
    {
        var next = states[State.Scare] as Scare;
        next.SetState(this, scareSpan);

        return next;
    }

    public IState Calm()
    {
        return this;
    }

    public IState Eaten()
    {
        OnTouch(this, EventArgs.Empty);

        return this;
    }

    //準備中ワープは絶対しない。
    public void Warp(Vector2 pos, float warpSpan)
    {
        throw new System.NotImplementedException();
    }

    public void Animate()
    {
        animator.SetFloat("DirX", mover.Direction.x);
        animator.SetFloat("DirY", mover.Direction.y);
    }
}

Scatterクラス

public class Scatter : IState
{
    public event EventHandler OnTouch;
    private readonly Dictionary<State, IState> states;
    //巡回する座標。
    private readonly Queue<Vector2> waypoints;
    private readonly Mover mover;
    private readonly Animator animator;
    //巡回期間。
    private readonly float span;
    //巡回終了時間。
    private float limitTime;

    public Scatter(Mover mover, Dictionary<State, IState> states,
        Animator animator, Queue<Vector2> waypoints, float span)
    {
        this.mover = mover;
        this.states = states;
        this.animator = animator;
        this.waypoints = waypoints;
        this.span = span;

        states.Add(State.Scatter, this);
    }

    //一定時間巡回した後、追跡状態になる。
    public IState Excute()
    {
        if (limitTime < Time.fixedTime)
        {
            var next = states[State.Chase] as Chase;
            next.SetState();

            return next;
        }

        mover.MoveToWaypoints(true);

        return this;
    }

    public void SetState()
    {
        limitTime = Time.fixedTime + span;
        mover.SetWaypoints(waypoints);
    }

    public IState Frighten(float scareSpan)
    {
        var next = states[State.Scare] as Scare;
        next.SetState(this, scareSpan);

        return next;
    }

    public IState Calm()
    {
        return this;
    }

    public IState Eaten()
    {
        OnTouch(this, EventArgs.Empty);

        return this;
    }

    //巡回中ワープは絶対しない。
    public void Warp(Vector2 pos, float warpSpan)
    {
        throw new System.NotImplementedException();
    }

    public void Animate()
    {
        animator.SetFloat("DirX", mover.Direction.x);
        animator.SetFloat("DirY", mover.Direction.y);
    }
}

Chaseクラス

public class Chase : IState
{
    public event EventHandler OnTouch;
    private readonly Dictionary<State, IState> states;
    private readonly Mover mover;
    private readonly Animator animator;
    private readonly float span;
    private readonly SpriteRenderer sprite;
    //ワープ中かどうか。
    private bool warped;
    //残り時間。
    private float leftSpan;
    //追跡終了時間。
    private float limitTime;
    //ワープ終了時間。
    private float warpEndTime;

    public Chase(Mover mover, Dictionary<State, IState> states, 
        Animator animator, SpriteRenderer sprite, float span)
    {
        this.mover = mover;
        this.states = states;
        this.animator = animator;
        this.sprite = sprite;
        this.span = span;

        states.Add(State.Chase, this);
    }

    //一定時間追跡した後、帰還状態になる。
    public IState Excute()
    {
        if (!warped)
        {
            if (limitTime < Time.fixedTime)
            {
                leftSpan = 0;

                var next = states[State.Return] as Return;
                next.SetState();

                return next;
            }
            else
            {
                mover.MoveToWaypoints(State.Chase);
                return this;
            }
        }
        else //ワープ中。
        {
            if (warpEndTime < Time.fixedTime)
            {
                sprite.enabled = true;
                warped = false;
                limitTime = leftSpan + Time.fixedTime;
            }

            return this;
        }
    }

    public void SetState()
    {
        limitTime = Time.fixedTime + span;
    }

    public IState Frighten(float scareSpan)
    {
        //追跡時間を延長。
        limitTime += scareSpan;

        var next = states[State.Scare] as Scare;
        next.SetState(this, scareSpan);

        return next;
    }

    public IState Calm()
    {
        return this;
    }

    public IState Eaten()
    {
        OnTouch(this, EventArgs.Empty);

        return this;
    }

    public void Warp(Vector2 pos, float warpSpan)
    {
        sprite.enabled = false;

        //追跡の残り時間を記録。
        leftSpan = Mathf.Max(limitTime - Time.fixedTime, 0);
        warpEndTime = Time.fixedTime + warpSpan;

        warped = true;
        mover.Warp(pos);
    }

    public void Animate()
    {
        animator.SetFloat("DirX", mover.Direction.x);
        animator.SetFloat("DirY", mover.Direction.y);
    }
}

Scareクラス

public class Scare : IState
{
    public event EventHandler OnTouch;
    private readonly Dictionary<State, IState> states;
    private readonly Mover mover;
    private readonly Animator animator;
    private readonly float defaultSpeed;
    private readonly SpriteRenderer sprite;
    //元の状態。
    private IState preState;
    //ワープ中かどうか。
    private bool warped;
    //恐慌終了時間。
    private float limitTime;
    //ワープ終了時間。
    private float warpEndTime;

    public Scare(Mover mover, Dictionary<State, IState> states, 
        Animator animator, SpriteRenderer sprite)
    {
        this.mover = mover;
        this.states = states;
        this.animator = animator;
        this.sprite = sprite;
        defaultSpeed = mover.Speed;
        
        states.Add(State.Scare, this);
    }

    public IState Excute()
    {
        IState state = this;

        if (!warped)
        {
            if (preState is Wait || preState is Init ||
                    preState is Scatter)
            {
                //元の状態での行動を続ける。
                preState = preState.Excute();
            }
            else
            {
                //ランダムに移動。
                mover.MoveToWaypoints(State.Scare);
            }
        }
        else //ワープ中。
        {
            if (warpEndTime < Time.fixedTime)
            {
                sprite.enabled = true;
                warped = false;
            }
        }
        
        return state;
    }

    public void SetState(IState preState, float span)
    {
        this.preState = preState;
        limitTime = Time.fixedTime + span;
        
        mover.Speed = defaultSpeed * 0.8f;

        animator.SetBool("IsScare", true);
    }

    //恐慌中にパックパンがパワーエサを食べたら、恐慌時間は上書き。
    public IState Frighten(float span)
    {
        limitTime = Time.fixedTime + span;

        return this;
    }

    public IState Calm()
    {
        mover.Speed = defaultSpeed;
        sprite.enabled = true;
        warped = false;

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

        //恐慌状態が終わったら、元の状態になる。
        return preState;
    }

    public IState Eaten()
    {
        OnTouch(this, EventArgs.Empty);

        var next = states[State.Dead] as Dead;
        next.SetState();

        return next;
    }

    public void Warp(Vector2 pos, float warpSpan)
    {
        sprite.enabled = false;

        warpEndTime = Time.fixedTime + warpSpan;

        warped = true;
        mover.Warp(pos);
    }

    public void Animate()
    {
        //残り期間が3秒をきったら点滅。
        if (limitTime - Time.fixedTime < 3)
        {
            animator.SetBool("IsCalmSoon", true);
        }
        else
        {
            animator.SetBool("IsCalmSoon", false);
        }
    }
}

Deadクラス

public class Dead : IState
{
    public event EventHandler OnTouch;
    private readonly Dictionary<State, IState> states;
    private readonly Mover mover;
    private readonly Animator animator;
    //巣の付近の座標。
    private readonly Queue<Vector2> nestWaypoints;
    private readonly SoundManager soundManager;
    private readonly float defaultSpeed;
    //巣の近くにいるかどうか。
    private bool isArriveNearNest;
    
    public Dead(Mover mover, Dictionary<State, IState> states,
        Animator animator, Queue<Vector2> nestWaypoints)
    {
        this.mover = mover;
        this.states = states;
        this.animator = animator;
        this.nestWaypoints = nestWaypoints;
        defaultSpeed = mover.Speed;

        states.Add(State.Dead, this);

        soundManager = SoundManager.Instance;
    }

    public IState Excute()
    {
        IState next = this;

        //巣の近くに来るまでの移動。
        if (!isArriveNearNest)
        {
            mover.MoveToWaypointsThen(nestWaypoints.Peek(), 
                () => isArriveNearNest = true);
        }
        else //巣の付近での移動。巣に戻ったら、待機状態になる。
        {
            mover.MoveToWaypointsThen(() =>
            {
                mover.Speed = defaultSpeed;
                isArriveNearNest = false;

                var wait = states[State.Wait] as Wait;
                wait.SetState();

                next = wait;

                animator.SetBool("IsDead", false);
                soundManager.StopSE();
            });
        }

        return next;
    }

    public void SetState()
    {
        mover.SetWaypoints(nestWaypoints);
        mover.Speed = defaultSpeed *2f;

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

        soundManager.PlaySE("GhostDead", 0.2f);
    }

    public IState Frighten(float scareSpan)
    {
        return this;
    }

    public IState Calm()
    {
        return this;
    }

    public IState Eaten()
    {
        OnTouch(this, EventArgs.Empty);

        return this;
    }

    public void Warp(Vector2 pos, float warpSpan)
    {
        mover.Warp(pos);
    }

    public void Animate()
    {
        animator.SetFloat("DirX", mover.Direction.x);
        animator.SetFloat("DirY", mover.Direction.y);
    }
}

Returnクラス

public class Return : IState
{
    public event EventHandler OnTouch;
    private readonly Dictionary<State, IState> states;
    private readonly Mover mover;
    private readonly Animator animator;
    private readonly Vector2 scatterPoint;
    private readonly SpriteRenderer sprite;
    private Scatter next;
    //ワープ中かどうか。
    private bool warped;
    //ワープ終了時間。
    private float warpEndTime;

    public Return(Mover mover, Dictionary<State, IState> states, 
        Animator animator, SpriteRenderer sprite, Vector2 scatterPoint)
    {
        this.mover = mover;
        this.states = states;
        this.animator = animator;
        this.sprite = sprite;
        this.scatterPoint = scatterPoint;

        states.Add(State.Return, this);
    }

    //巡回開始の座標まで移動。到着後は巡回状態になる。
    public IState Excute()
    {
        IState state = this;

        if (!warped)
        {
            if (next == null)
            {
                mover.MoveToWaypointsThen(scatterPoint,
                () =>
                {
                    next = states[State.Scatter] as Scatter;
                    next.SetState();
                });
            }
            else state = next;        
        }
        else //ワープ中。
        {
            if (warpEndTime < Time.fixedTime)
            {
                sprite.enabled = true;
                warped = false;
            }
        }

        return state;
    }

    public void SetState()
    {
        next = null;
    }

    public IState Frighten(float scareSpan)
    {
        var next = states[State.Scare] as Scare;
        next.SetState(this, scareSpan);

        return next;
    }

    public IState Calm()
    {
        return this;
    }

    public IState Eaten()
    {
        OnTouch(this, EventArgs.Empty);

        return this;
    }

    public void Warp(Vector2 pos, float warpSpan)
    {
        sprite.enabled = false;

        warpEndTime = Time.fixedTime + warpSpan;

        warped = true;
        mover.Warp(pos);
    }

    public void Animate()
    {
        animator.SetFloat("DirX", mover.Direction.x);
        animator.SetFloat("DirY", mover.Direction.y);
    }
}

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

ゴーストオブジェクトの作成

16px × 16pxの画像を用意し、Pixels Per Unitを8にします。画像からSpriteを作成し、Rigidbody2D、BoxCollider2Dをアタッチします。適当にColliderの大きさを設定します。

Sprite画像

ゴーストオブジェクト

状態の管理

ゴーストは最初、巣に待機しており(アカベイは除く)、一定時間経過すると特定のエリアを巡回するようになります。一定時間巡回するとパックマンを追跡するようになります。一定時間追跡するとまた特定のエリアを巡回するようになります。パックマンがパワーエサを食べると恐慌状態になり、このときパックマンに食べられると、死亡状態となります。死亡状態では一旦巣に戻り、巣に入ると待機状態になります。

ゴーストの状態遷移

これら状態遷移と行動を実装します。今回はStateパターンを使いますが、if文やSwitch文の方が簡単かもしれません。

状態クラスについては下記を参照してください。

nullsuke.com

Stateパターンについては下記のサイトを参照してください。

qiita.com

抽象クラスAGhostの作成

状態クラスを使って移動や処理する抽象クラスです。ワープの為のインターフェイスIWarpableとパックマンに食べられる為のインターフェイスIEatableを継承します。

AGhost抽象クラス

public abstract class AGhost : MonoBehaviour, IWarpable, IEatable
{
    //待機間隔。
    [SerializeField] protected float waitSpan;
    //巡回間隔。
    [SerializeField] protected float scatterSpan;
    //追跡間隔。
    [SerializeField] protected float chaseSpan;
    //恐怖間隔。
    [SerializeField] protected float scareTime;
    //パックマンに食べられたときの処理を登録。
    public event EventHandler OnEaten;
    //パックマンを食べたときの処理を登録。
    public event EventHandler OnEat;
    //ワープ時間。
    private readonly float warpSpan = 1f;
    private readonly int score = 200;
    private SpriteRenderer sprite;
    private Animator animator;
    private IState state;
    private Wait wait;
    private float pauseEndTime;

    public int Score { get => score; }

    //初期化。
    public void Initialize(Mover mover, GhostWaypointsData gwd, 
        List<Vector2> nestWaypoints)
    {
        var states = new Dictionary<State, IState>();
        pauseEndTime = 0;

        wait = new Wait(mover, states, animator, ToQueue(gwd.Wait), waitSpan);
        wait.OnTouch += (s, e) => OnEat(s, e);

        var init = new Init(mover, states, animator, ToQueue(gwd.Init));
        init.OnTouch += (s, e) => OnEat(s, e);

        var scatter = new Scatter(mover, states, animator, 
            ToQueue(gwd.Scatter), scatterSpan);
        scatter.OnTouch += (s, e) => OnEat(s, e);

        var chase = new Chase(mover, states, animator, sprite, chaseSpan);
        chase.OnTouch += (s, e) => OnEat(s, e);

        var scare = new Scare(mover, states, animator, sprite);
        scare.OnTouch += (s, e) => OnEaten(s, e);

        var ret = new Return(mover, states, animator, sprite,
            ToQueue(gwd.Scatter).Peek());
        ret.OnTouch += (s, e) => OnEat(s, e);

        var dead = new Dead(mover, states, animator,
            ToQueue(nestWaypoints));
        dead.OnTouch += (s, e) => { };

        enabled = false;
        animator.enabled = false;
    }

    //ワープ。
    public void Warp(Vector2 pos)
    {
        state.Warp(pos, warpSpan);
    }

    //パックマンに食べられる。
    public void Eaten(Pacman pacman)
    {
        state = state.Eaten();
    }

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

    //恐慌。
    public void Scare(float span)
    {
        state = state.Frighten(span);
    }

    //恐慌終了。
    public void Calm()
    {
        state = state.Calm();
    }

    //起動。
    public void Run()
    {
        wait.SetState();
        state = wait;
        enabled = true;
        animator.enabled = true;
    }

    //一定時間停止。
    public void Pause(float span)
    {
        pauseEndTime = Time.fixedTime + span;
    }

    //停止。
    public void Stop()
    {
        enabled = false;
        animator.enabled = false;
    }

    private void Awake()
    {
        sprite = GetComponent<SpriteRenderer>();
        animator = GetComponent<Animator>();
    }

    //移動・アニメーション。
    private void FixedUpdate()
    {
        if (Time.fixedTime < pauseEndTime) return;

        state = state.Excute();
        state.Animate();
    }

    //List<Vector2>からQueue<Vector2>へ変換。
    private Queue<Vector2> ToQueue(List<Vector2> waypoints)
    {
        var wps = new Queue<Vector2>();

        waypoints.ForEach(w =>
        {
            wps.Enqueue(w);
        });

        return wps;
    }
}

各ゴーストのクラスを作成

AGhostを継承して各ゴーストのクラスを作成します。各ゴーストのAIついては下記を参照してください。

アカベイ

Akabeiクラス

public class Akabei : AGhost
{
    public void Initialize(Maze maze, Pacman pacman)
    {
        transform.localPosition = maze.AkabeiWaypointsData.Start;
        
        var ai = GetComponent<AkabeiAI>();
        ai.Initialize(pacman, maze.TileUtility);
        
        var mover = GetComponent<Mover>();
        mover.Initialize(ai);

        base.Initialize(mover, maze.AkabeiWaypointsData, maze.NestWaypoints);
    }
}

ピンキー

Pinkyクラス

public class Pinky : AGhost
{
    public void Initialize(Maze maze, Pacman pacman)
    {
        transform.localPosition = maze.PinkyWaypointsData.Start;

        var ai = GetComponent<PinkyAI>();
        ai.Initialize(pacman, maze.TileUtility);

        var mover = GetComponent<Mover>();
        mover.Initialize(ai);

        base.Initialize(mover, maze.PinkyWaypointsData, maze.NestWaypoints);
    }
}

アオスケ

Aosukeクラス

public class Aosuke : AGhost
{
    public void Initialize(Maze maze, Pacman pacman, Akabei akabei)
    {
        transform.localPosition = maze.AosukeWaypointsData.Start;
        
        var ai = GetComponent<AosukeAI>();
        ai.Initialize(pacman, maze.TileUtility, akabei);
        
        var mover = GetComponent<Mover>();
        mover.Initialize(ai);
        
        base.Initialize(mover, maze.AosukeWaypointsData, maze.NestWaypoints);
    }
}

グズタ

Guzutaクラス

public class Guzuta : AGhost
{
    public void Initialize(Maze maze, Pacman pacman)
    {
        transform.localPosition = maze.GuzutaWaypointsData.Start;

        var ai = GetComponent<GuzutaAI>();
        ai.Initialize(pacman, maze.TileUtility);
        
        var mover = GetComponent<Mover>();
        mover.Initialize(ai);
        
        base.Initialize(mover, maze.GuzutaWaypointsData, maze.NestWaypoints);
    }
}

完成

ゴーストオブジェクトにゴーストクラス、ゴーストAI、Mover、Animatorをアタッチし、待機時間などパラメータを設定します。

アカベイ、ピンキー

アオスケ、グズタ

迷路上にゴーストをセットすれば完成です。

PlaceGhost関数

public class GameManager : MonoBehaviour
{
    [SerializeField] private Pacman pacmanPrefab = default;
    [SerializeField] private Maze[] mazePrefabs = default;
    [SerializeField] private Akabei akabeiPrefab = default;
    [SerializeField] private Pinky pinkyPrefab = default;
    [SerializeField] private Aosuke aosukePrefab = default;
    [SerializeField] private Guzuta guzutaPrefab = default;
    private List<AGhost> ghosts;
    private Pacman pacman;
    private Maze maze;
    private Akabei akabei;
    private Pinky pinky;
    private Aosuke aosuke;
    private Guzuta guzuta;
    //恐怖状態かどうか。
    private bool isScare;
    private int score;
    //一度の恐怖状態で食べたゴーストの数。
    private int eatenGhost;
    //食べたエサの数。
    private int eatenDot;

    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;
                
                eatenGhost++;
            };

            //食べたときのイベント。
            g.OnEat += (s, e) =>
            {
                pacman.Dead();
                isScare = false;
                lives--;
            };
        });
    }
}

ゴーストの完成

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

仕様はいたってシンプルです。

• キーを押したら障害物にぶつかるまで進み続ける。
• 移動中にキーを押すと、その方向に移動できるようになったとき自動的にその方向に進む。
• ワープ地点に来たら反対側にワープする。
• エサ、パワーエサ、フルーツ、怯えた状態のゴーストを食べる。
• 通常状態のゴーストに食べられる。

Pacmanオブジェクトの作成

16px × 16pxの画像を用意し、Pixels Per Unitを8にします。画像はUnityのSprite Packerを使って1つの画像にまとめるとゲーム起動時の負荷が減ります。

Sprite画像

画像からSpriteを作成し、Rigidbody2D、CirlceCollider2Dをアタッチします。適当にColliderの大きさを設定します。

Pacmanオブジェクト

Pacmanクラスの作成

移動

当たり判定

Physics2D.Linecastを使います。この関数の引数はグローバル座標なので注意してください。

CanMove

private Collider2D collider2d;

//dirはパックマンの進行方向。
private bool CanMove(Vector2 dir)
{
    Vector2 p = transform.position;
    var hit = Physics2D.Linecast(p + dir, p);

    return hit.collider == collider2d;
}

フレームごとの移動

Vector2.MoveTowardsを使い現在座標、目標座標、移動速度からフレーム毎の移動座標を求め、Rigid2D.MovePositionで移動させます。

目標座標に限りなく近づいたら壁との当たり判定を行い、判定が偽の場合移動します。

また、キー入力もここで行います。

Move

[SerializeField] private float speed;
private Rigidbody2D rigid2D;
private Vector2 dest;
private Vector2 nextDir;

public Vector2 Direction { get; private set; }

private void Move()
{
    var p = Vector2.MoveTowards(transform.position, dest, speed);
    rigid2D.MovePosition(p);

    if (Input.GetAxis("Horizontal") > 0) nextDir = Vector2.right;
    if (Input.GetAxis("Horizontal") < 0) nextDir = Vector2.left;
    if (Input.GetAxis("Vertical") > 0) nextDir = Vector2.up;
    if (Input.GetAxis("Vertical") < 0) nextDir = Vector2.down;
    
    if (Vector2.Distance(dest, transform.position) < float.Epsilon)
    {
        if (CanMove(nextDir))
        {
            dest = (Vector2)transform.position + nextDir;
            Direction = nextDir;
        }
        else
        {
            if (CanMove(Direction))
            {
                dest = (Vector2)transform.position + Direction;
            }
        }
    }
}

ワープ

パックマンの現在地をWarpPointの出口にし、進行方向を1つ先に設定するだけです。継承したIWarpable.Warpに実装し、WarpPointに接触したら実行するようにします。

Warp

//posはワープの出口の座標
public void Warp(Vector2 pos)
{
    transform.localPosition = pos;
    dest = (Vector2)transform.position + Direction;
}

食べる

パックマンが食べることができるもの(エサ、パワーエサ、恐慌状態のゴースト、フルーツ)にIEatableインターフェイスを継承します。食べたときの動作は食べられる側で実装します。パックマン側はOnTriggerEnter2DでIEatable.Eatenを実行するだけです。

IEatableインターフェイス

public interface IEatable
{
    event EventHandler OnEaten;    
    int Score { get; }
    void Eaten(Pacman pacman = null);
    void Destroy();
}

OnTriggerEnter2D

private void OnTriggerEnter2D(Collider2D collider)
{
    var e = collider.GetComponent<IEatable>();
    e?.Eaten(this);
}

アニメーション

上下左右の移動と死亡時のアニメーションを作成します。 すべてのアニメーションはAny Stateから遷移するようにします。 Animation ControllerのParametersに以下の変数を作成します。

• float DirX
• float DirY
• bool isDead

Animation Controller

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

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

UpへのTransition

死亡のアニメション終了と同時に自身を削除するようにしておきます。

死亡のアニメーション終了後の設定

Destroy

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

移動時に、DirXとDirYにパックマンの進行方向を代入します。

Animate

private void Animate()
{
    animator.SetFloat("DirX", Direction.x);
    animator.SetFloat("DirY", Direction.y);
}

死亡時に、IsDeadを真にします。

Dead

public void Dead()
{
    animator.SetBool("IsDead", true);
}

完成

PacmanオブジェクトにAnimator、Pacmanクラスをアタッチします。適当にSpeedを設定します。

Pacmanオブジェクト

毎フレーム、MoveとAnimateを実行させます。

FixUpdate

private void FixedUpdate()
{
    Move();
    Animate();
}

nullsuke.com

上記で作成した迷路上にパックマンをセットすれば完成です。パックマンの初期位置は必ず整数にしてください。そうしないと、移動中に引っかかってしまいます。

パックマン(キャラのみ)の完成

Unityによるパックマンの作り方 ～半自動でBoxCollider2Dをセット～

BoxCollider2Dに必要な中心座標、サイズをを取得したいが、直接迷路の画像から取得するのは難しい。なので、まずデータ取得用の画像(ColliderMap)を作成し、そこから必要なデータを取得するようにします。この取得したデータをもとに迷路の画像にBoxCollider2Dをアタッチします。

ColliderMapの作成

ここではClipStudioを使用していますが、下記の機能が使えるものなら何でもよいです。

• ベクターレイヤー。
• グリッドの表示、グリッドにスナップ。

迷路の画像のレイヤーの上からBoxCollider２Dの半分の大きさの短形を描いていきます。ベクターレイヤーで矩形をブラシサイズ1pxで描画し、ラスターレイヤーで適当な色で塗りつぶしていきます。このとき、適当なサイズでグリッドを表示し、グリッドにスナップするようにしておくと楽です。

ColliderMapの描画

ColliderMap

BoxCollider2Dそのものの短形にしないは、BoxCollider2Dが隣接しているとうまく座標を取得できないからです。

作成した画像はRead/Write Enableを有効にしておくこと。そうしないとスクリプトから画像を読み込めません。

ColliderMapの設定

ColliderMapから矩形を取得

以下の手順で矩形を取得していきます。

1. ColliderMapをTexture2Dとして読み込ます。
2. 原点(左下)から水平方向に、連続してある不透明な(α値が0でない)点を取得します。
3. 垂直方向に、2で取得した直線と同じ長さの不透明な直線があるか精査し、あれば取得します。
4. 2, 3を精査済みの点を飛ばしながら繰り返します。

MazeUtilityクラスでColliderMapの読み込み、精査、矩形の取得をします。取得した矩形をRectangleクラスで保存します。

MazeUtiiltyクラス

public class MazeUtility : MonoBehaviour
{
    private readonly List<Vector2> visited = new List<Vector2>();
    private Color[] pix;
    private int width;
    private int height;
    
    public List<Rectangle> GetRectangles(Texture2D sourceTex)
    {
        visited.Clear();
        width = sourceTex.width;
        height = sourceTex.height;
        pix = sourceTex.GetPixels(0, 0, width, height);

        var rects = new List<Rectangle>();

        for (int y = 0; y < height; y += Rectangle.Unit.y)
        {
            for (int x = 0; x < width; x += Rectangle.Unit.x)
            {
                var p = new Vector2(x, y);

                //既に精査済みの座標はパス。
                if (visited.Contains(p)) continue;

                int i = y * width + x;

                if (pix[i].a > 0)
                {
                    var rec = GetRectangle(p);
                    rects.Add(rec);
                }
            }
        }

        return rects;
    }

    //矩形を取得。
    private Rectangle GetRectangle(Vector2 p)
    {
        var rec = new Rectangle();
        var points = GetLinePoints(p);
        
        visited.AddRange(points);

        rec.BottomLeft = points[0];
        rec.Width = points.Count * Rectangle.Unit.x; ;

        int i;

        //垂直方向に精査し、座標を取得。
        do
        {
            p.y += Rectangle.Unit.y;
            
            if (p.y >= height) break;

            points = GetLinePoints(p);

            if (rec.Width != points.Count * Rectangle.Unit.x)
            {
                break;
            }
            else
            {
                visited.AddRange(points);
            }

            i = (int)p.y * width + (int)p.x;
        } while (pix[i].a > 0);

        rec.Height = p.y - rec.BottomLeft.y;

        return rec;
    }

    //水平方向に精査し、座標を取得。
    private List<Vector2> GetLinePoints(Vector2 p)
    {
        var points = new List<Vector2>();
        int i = (int)p.y * width + (int)p.x;

        while (p.x < width && pix[i].a > 0)
        {
            points.Add(p);
            p.x += Rectangle.Unit.x;
            i = (int)p.y * width + (int)p.x;
        } 

        return points;
    }
}

Rectangleクラス

public class Rectangle
{
    public static readonly Vector2Int Unit = new Vector2Int(2, 2);
    public Vector2 BottomLeft { get; set; }
    //ColliderMap上の矩形の幅
    public float Width { get; set; }
    //ColliderMap上の矩形の高さ
    public float Height { get; set; }
    //Maze上で必要な矩形の幅
    public float Width2 { get => Width * 2f; }
    //Maze上で必要な矩形の高さ
    public float Height2 { get => Height * 2f; }

    public Vector2 Center
    {
        get
        {
            var cx = BottomLeft.x + Width / 2f;
            var cy = BottomLeft.y + Height / 2f;

            return new Vector2(cx, cy);
        }
    }

    public Vector2 Center2
    {
        get
        {
            var cx = BottomLeft.x + Width;
            var cy = BottomLeft.y + Height;

            return new Vector2(cx, cy);
        }
    }
}

BoxCollider2Dをアタッチ

MazeオブジェクトにMazeUtilityをアタッチし、ColliderMapをセットします。Mazeオブジェクトが読み込まれたときBoxCollider2Dをアタッチするようにします。

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

MazeUtilityで得た矩形は必要な矩形の半分の大きさなので2倍した値を使います。また、迷路の画像はPixels Per Unitを8pxにしているので8で割ります。

Mazeクラス

public class Maze : MonoBehaviour
{
    [SerializeField] private Texture2D boxColliderMap;
    private MazeUtility mazeUtility;

    private void Start()
    {
        var boxes = mazeUtility.GetRectangles(boxColliderMap);

        boxes.ForEach(b =>
        {
            //迷路の画像のPixel Per Unitが8なので8で割る。
            var c = b.Center2 / 8f;
            var w = b.Width2 / 8f;
            var h = b.Height2 / 8f;
            var size = new Vector2(w, h);

            AddBoxCollider2D(c, size);
        });
    }

    private void Awake()
    {
        mazeUtility = GetComponent<MazeUtility>();
    }

    //BoxCollider2Dをアタッチ。
    private void AddBoxCollider2D(Vector2 offset, Vector2 size)
    {
        var box = gameObject.AddComponent<BoxCollider2D>();
        box.offset = offset;
        box.size = size;
    }
}

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

Mazeオブジェクトの作成

迷路の画像を用意しスプライトを作成します。

迷路の画像

Pixel Per Unitを8、Pivotを左下にします(左下を原点にしておくと今後わかりやすいので)。

迷路の画像の設定

Mazeクラスを作成し、アタッチします。この時点で、クラスは空でかまいません。

Mazeゲームオブジェクト

BoxCollider2Dをアタッチ

迷路の壁部分にそれぞれBoxCollider2Dを0.25単位でアタッチします(0.25刻みでないとパックマンが移動中に引っかかってしまう)。

手作業でBoxCollider2Dをアタッチ

BoxCollider2Dの位置、サイズ

BoxCollider2D

手動でも十分可能ですが、半自動でアタッチすることもできます(といっても下準備に手間がかかるのですけどね)。

nullsuke.com

ワープ地点の作成

IWarpableインターフェイスを作成し、ワープさせたいキャラ(パックマン、ゴースト)に継承させます。

IWarpableインターフェイス

public interface IWarpable
{
    void Warp(Vector2 pos);
}

ワープ用のクラスWarpPointを作成します。これにワープの出口の座標を保持させ、IWarpable.Warpメソッドを使いワープの出口に瞬間移動させます。

WarpPointクラス

public class WarpPoint : MonoBehaviour
{
    //ワープ出口の座標。
    [SerializeField] private Vector2 warpOut = default;

    private void OnTriggerEnter2D(Collider2D collision)
    {
        var w = collision.GetComponent<IWarpable>();
        w.Warp(warpOut);
    }
}

空のGameObjectを2つ作成し、それぞれにBoxCollider2D、WarpPointをアタッチします。ワープの出口の座標は出た直後に、出口のワープポイントとキャラが接触しないよう少し離れた位置にしましょう。これらを迷路のワープの入り口にセットします。

WarpPoint位置

ワープポイントの設定

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

主に下記サイトを参考にしました。これらのサイトを読めば十分かもしれません(笑)。ただ、どのサイトも古く(まぁ、パックマン自体が古いが)、英語のサイトなので日本語で今風の作り方の解説もあってもよいかなとも思っています。

Unityによるパックマン作成のチュートリアルです。ここを見れば、8割方作れます。ただ、ゴーストの移動が一定だったり、パワーエサがなかったりと中途半端です。

noobtuts.com

Unityによるパックマンのソースです。上記のサイトにはないゴーストの移動などのソースがあります。

github.com

パックマンの仕様が書いてあります。ゴーストの移動の仕様などは参考になります。

gameinternals.com

迷路の作成

下記を参照してください。 nullsuke.com

パックマンの作成

下記を参照してください。 nullsuke.com

ゴーストの作成

下記を参照してください。 nullsuke.com

アイテムの作成

下記を参照してください。 nullsuke.com

BGM・SEを再生する

下記を参照してください。 nullsuke.com

完成

nullsuke.com

unityroomに自作ゲーム 「Let's Eat」 を公開しました

パックマンもどきのゲーム「Let's Eat」をunityroomに公開しました。近いうちに作成の解説も公開する予定です。

Let's Eat

unityroom.com