Unity C# 移動中の対象に対する経路探索

Question

前提

移動中の対象へ経路探索をしたい

コード

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using System.Linq;

namespace UtilityModule
{
    public class Moving_from_PositionA_to_PositionB : MonoBehaviour
    {
        private int map_Width = 100;
        private int map_Height = 100;
        private ChessboardPathFinder pathFinder;
        public List<Vector2> moveList = new List<Vector2>();
        private float speed = 2.5f;
        public bool stoped_Movement;
        //始動したコルーチンを覚えておくためのフィールドを追加し...
        private Coroutine movementAction;

        void Awake()
        {
            pathFinder = new ChessboardPathFinder(map_Width, map_Height);
        }

        public　bool Find_Path(Vector2Int startPosition,Vector2Int goalPosition)
        {
            bool pathFound = pathFinder.FindPath(startPosition, goalPosition);

            return pathFound;
        }

        public void Start_MovementAction()
        {
            //コルーチン始動時にそれを保存
            movementAction = StartCoroutine(Move());
        }

        //そして覚えておいたコルーチンを停止するためのメソッドを用意
        public void Stop_MovementAction()
        {
            if (movementAction != null)
            {
                StopCoroutine(movementAction);
                moveList.Clear();
            }
        }

        IEnumerator Move()
        {
            foreach (Vector2Int position in pathFinder.Path.Skip(1))
            {
                Vector2 pos = new Vector3(position.x, position.y);
                moveList.Add(pos);
            }

            Vector2 unitPos = new Vector2(gameObject.transform.position.x, gameObject.transform.position.y);
            if(moveList.Contains(unitPos))
            {
                moveList.Remove(unitPos);
            }

            int count = 0;

            while (true)
            {
                if(stoped_Movement)
                {
                    break;
                }

                gameObject.transform.position = Vector2.MoveTowards(gameObject.transform.position, moveList[count], speed * Time.deltaTime);

                if (count < moveList.Count - 1)
                {
                    count++;
                }

                if (gameObject.transform.position == (Vector3)moveList[moveList.Count - 1])
                {
                    break;
                }

                yield return null;
            }
        }
    }
}

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Module_of_Unit;
using UtilityModule;

namespace Module_of_Berserkermode
{
    public class Berserkermode : MonoBehaviour
    {
        private Unit_RandomWalk unit_RandomWalk;
        private Unit gameObjectUnit;
        private Moving_from_PositionA_to_PositionB moving_From_PositionA_To_PositionB;
        private Unit_RandomWalk unit_RandomWalk_SelectedUnit;
        private GameObject selectedUnit;
        private bool get_Distance;
        private bool switched_Berserkermode;
        //前回のUpdateで調べたターゲットの位置を保存するためのフィールドを追加
        private Vector2Int latestTargetPos;

        private void Awake()
        {
            unit_RandomWalk = gameObject.GetComponent<Unit_RandomWalk>();
            gameObjectUnit = gameObject.GetComponent<Unit>();
            moving_From_PositionA_To_PositionB = gameObject.GetComponent<Moving_from_PositionA_to_PositionB>();
        }

        public void Action()
        {
            //不満値が１００％になったら、ランダム移動を停止する
            unit_RandomWalk.Stop_RandomWalk();

            Invoke("Go", 1);
        }

        private void Go()
        {
            //ランダムに対象を選択する
            int random = Random.Range(0, gameObjectUnit.playerOwnedUnits_List.Count);
            selectedUnit = gameObjectUnit.playerOwnedUnits_List[random];
            unit_RandomWalk_SelectedUnit = selectedUnit.GetComponent<Unit_RandomWalk>();
            get_Distance = true;
            switched_Berserkermode = true;

            //対象がいた座標に向かって移動する
            Go_To_TargetUnit();
        }

        private void Update()
        {
            if(get_Distance)
            {
                //このユニットと対象のユニットの距離が、５タイル以内に入ったら、対象のユニットの移動を停止する
                float distanse = Vector2.Distance(gameObject.transform.position, selectedUnit.transform.position);
                if (distanse <= 3)
                {
                    unit_RandomWalk_SelectedUnit.Stop_RandomWalk();
                    int x = Mathf.RoundToInt(unit_RandomWalk_SelectedUnit.transform.position.x);
                    int y = Mathf.RoundToInt(unit_RandomWalk_SelectedUnit.transform.position.y);
                    unit_RandomWalk_SelectedUnit.transform.position = new Vector3(x, y, 0);
                }
            }

            //対象のユニットが存在していた座標に到達したら、また移動する
            /*
            if (switched_Berserkermode && gameObject.transform.position == (Vector3)moving_From_PositionA_To_PositionB.moveList[moving_From_PositionA_To_PositionB.moveList.Count - 1])
            {
                Go_To_TargetUnit();
            }
            */

            if (switched_Berserkermode)
            {
                //現在のターゲットの位置を調べ...
                Vector2Int targetPos = new Vector2Int((int)selectedUnit.transform.position.x, (int)selectedUnit.transform.position.y);

                //敵の位置に変化があったら...
                if (targetPos != latestTargetPos)
                {
                    //現在動作中の移動コルーチンは中止し、目的地への経路を再計算
                    latestTargetPos = targetPos;
                    Stop_Movement();
                    Go_To_TargetUnit();
                }
            }
        }

        void Stop_Movement()
        {
            moving_From_PositionA_To_PositionB.Stop_MovementAction();
        }

        void Go_To_TargetUnit()
        {
            //moving_From_PositionA_To_PositionB.moveList.Clear();

            Vector2Int startPos = new Vector2Int((int)gameObject.transform.position.x, (int)gameObject.transform.position.y);
            Vector2Int goalPos = new Vector2Int((int)selectedUnit.transform.position.x, (int)selectedUnit.transform.position.y);

            Vector2Int up = new Vector2Int(goalPos.x, goalPos.y + 1);
            Vector2Int down = new Vector2Int(goalPos.x, goalPos.y - 1);
            Vector2Int right = new Vector2Int(goalPos.x + 1, goalPos.y);
            Vector2Int left = new Vector2Int(goalPos.x - 1, goalPos.y);

            float up_Distance = Vector2.Distance(startPos, up);
            float down_Distance = Vector2.Distance(startPos, down);
            float right_Distance = Vector2.Distance(startPos, right);
            float left_Distance = Vector2.Distance(startPos, left);

            float min = Mathf.Min(up_Distance, down_Distance, right_Distance, left_Distance);

            if(min == up_Distance)
            {
                goalPos = up;
            }

            if (min == down_Distance)
            {
                goalPos = down;
            }

            if (min == right_Distance)
            {
                goalPos = right;
            }

            if (min == left_Distance)
            {
                goalPos = left;
            }

            if (moving_From_PositionA_To_PositionB.Find_Path(startPos, goalPos))
            {
                moving_From_PositionA_To_PositionB.Start_MovementAction();
            }
        }
    }
}

試したこと

![

【回答を追記・編集しました】
ユニットはランダムに移動しているのですが、ユニットの「不満値」というパラメータが１００になると、他のユニットの隣接に移動して、攻撃する、という実装にしようと思っていました。
ユニットが移動するスクリプトはUnit_RandomWalk.csというスクリプトです。すべてのユニットにこのスクリプトがアタッチされています。
目的のユニットが移動するたびに経路が再計算されるため、上記の図のように、ぐらぐらと揺れながら移動してしまっています。

Answer 1

ご提示のスクリプト以外にもご質問者さんオリジナルのスクリプトがいくつかあるようですので、私の方での動作確認はちょっと難しく手探りになってしまいすみませんが、まずMoving_from_PositionA_to_PositionBのStart_MovementAction周辺を下記のようにしておいて...

		//始動したコルーチンを覚えておくためのフィールドを追加し...
		private Coroutine movementAction;

		public void Start_MovementAction()
		{
			//コルーチン始動時にそれを保存
			movementAction = StartCoroutine(Move());
		}

		//そして覚えておいたコルーチンを停止するためのメソッドを用意
		public void Stop_MovementAction()
		{
			if (movementAction != null)
			{
				StopCoroutine(movementAction);
			}
		}

そしてBerserkermode側のUpdate周辺は...

		//前回のUpdateで調べたターゲットの位置を保存するためのフィールドを追加
		private Vector2Int latestTargetPos;

		private void Update()
		{
			if(get_Distance)
			{
				float distanse = Vector2.Distance(gameObject.transform.position, selectedUnit.transform.position);
				if (distanse <= 3)
				{
					unit_RandomWalk_SelectedUnit.stoped_RandomWalk = true;
					int x = Mathf.RoundToInt(unit_RandomWalk_SelectedUnit.transform.position.x);
					int y = Mathf.RoundToInt(unit_RandomWalk_SelectedUnit.transform.position.y);
					unit_RandomWalk_SelectedUnit.transform.position = new Vector3(x, y, 0);
				}
			}
			
			//対象のユニットが存在していた座標に到達したら、ではなく...
			/*
			if (switched_Berserkermode && gameObject.transform.position == (Vector3)moving_From_PositionA_To_PositionB.moveList[moving_From_PositionA_To_PositionB.moveList.Count - 1])
			{
				Go_To_TargetUnit();
			}
			*/

			if (switched_Berserkermode)
			{
				//現在のターゲットの位置を調べ...
				Vector2Int targetPos = new Vector2Int((int)selectedUnit.transform.position.x, (int)selectedUnit.transform.position.y);

				//敵の位置に変化があったら...
				if (targetPos != latestTargetPos)
				{
					//現在動作中の移動コルーチンは中止し、目的地への経路を再計算
					latestTargetPos = targetPos;
					moving_From_PositionA_To_PositionB.Stop_MovementAction();
					Go_To_TargetUnit();
				}
			}
		}

とするのはどうでしょうか?

すみませんが上記のコードは実験が不十分ですので、そのままではうまくいくかどうか不確かです。意図としては要するに、ターゲットが動くたびに経路を再計算する必要があるんじゃないか...ということでして、ご質問者さんのスタイルに合わせて自由に書き換えてしまってください。

何度も再計算するのは重そうに見えるかもしれませんが、経路がよっぽど長くなる...たとえば複雑な迷路状のマップで、ターゲットにたどり着くにはかなりの回り道をしなければいけない状況が頻発するとかでなければ、案外問題ないんじゃないかという気がします。
これだと計算量が多すぎるようでしたら、「Unity A*(A-Star)アルゴリズム　挙動がおかしくなる」のコメントで申し上げたような、非同期化して他の処理へのインパクトを抑制するみたいな対策が必要かもしれませんね。

私の場合の実装例

まず、ご質問者さんのUnit_RandomWalkの代用品として下記のようなスクリプトを用意しました。これを各ユニットにアタッチして徘徊させます。

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;

public class RandomWalk : MonoBehaviour
{
	private static readonly Vector2[] Directions = {Vector2.up, Vector2.right, Vector2.down, Vector2.left};

	[SerializeField][Min(0.0f)] private float idleDuration = 1.0f;
	[SerializeField][Min(0.0f)] private float walkDuration = 0.5f;

	private Coroutine randomWalkCoroutine;

	private void Start()
	{
		Physics2D.queriesStartInColliders = false;
		StartRandomWalk();
	}

	public void StartRandomWalk()
	{
		StopRandomWalk();
		randomWalkCoroutine = StartCoroutine(RandomWalkLogic());
	}

	public void StopRandomWalk()
	{
		if (randomWalkCoroutine == null)
		{
			return;
		}

		StopCoroutine(randomWalkCoroutine);
		randomWalkCoroutine = null;
	}

	private IEnumerator RandomWalkLogic()
	{
		WaitForSeconds wait = new WaitForSeconds(idleDuration);
		List<Vector2> randomizedDirections = new List<Vector2>(4);
		while (true)
		{
			yield return wait;

			Vector2 currentPosition = this.transform.position;
			randomizedDirections.Clear();
			randomizedDirections.AddRange(Directions.Where(d => !Physics2D.Raycast(currentPosition, d, 1.0f)));
			if (randomizedDirections.Count > 0)
			{
				Vector2 randomDirection = randomizedDirections[Random.Range(0, randomizedDirections.Count)];
				Vector3 velocity = randomDirection / this.walkDuration;
				float t = 0.0f;
				while (true)
				{
					transform.Translate(velocity * Time.deltaTime);
					t += Time.deltaTime;
					if (t >= walkDuration)
					{
						break;
					}
					yield return null;
				}
				transform.position = currentPosition + randomDirection;
			}
		}
	}
}

そしてMoving_from_PositionA_to_PositionBですが、後述しますがBerserkermode側で移動動作を行わせようと思った都合から、下記のように変更を加えました。思考の整理上（そして字数の節約上）すみませんが大部分を削除してしまいましたので、必要な部分までなくなってしまっている可能性があります。あくまでも参考ということでご容赦ください。

using System.Collections.ObjectModel;
using UnityEngine;

namespace UtilityModule
{
	public class Moving_from_PositionA_to_PositionB : MonoBehaviour
	{
		private readonly int map_Height = 250;
		private readonly int map_Width = 250;
		private ChessboardPathFinder pathFinder;

		public ReadOnlyCollection<Vector2Int> Path => pathFinder.Path;

		private void Awake()
		{
			pathFinder = new ChessboardPathFinder(map_Width, map_Height);
		}

		public bool Find_Path(Vector2Int startPosition, Vector2Int goalPosition)
		{
			bool pathFound = pathFinder.FindPath(startPosition, goalPosition);
			return pathFound;
		}
	}
}

Berserkermodeは下記のようにしました。これも同様にちょっと作りが変わってしまいましたので、参考として割り切っていただけるとありがたいです。

using System.Collections;
using System.Linq;
using UnityEngine;
using UtilityModule;

namespace Module_of_Berserkermode
{
	public class Berserkermode : MonoBehaviour
	{
		[SerializeField] private Material berserkerModeMaterial;
		[SerializeField] private Material nonBerserkerModeMaterial;
		[SerializeField][Min(0.0f)] private float walkDuration = 0.25f;

		private Moving_from_PositionA_to_PositionB moving_From_PositionA_To_PositionB;
		private Coroutine berserkerModeCoroutine;
		private bool needsStopBerserkerMode;
		private RandomWalk randomWalk;
		private new Renderer renderer;

		private bool IsBerserkerMode => berserkerModeCoroutine != null;

		private void Awake()
		{
			moving_From_PositionA_To_PositionB = gameObject.GetComponent<Moving_from_PositionA_to_PositionB>();
			randomWalk = GetComponent<RandomWalk>();
			renderer = GetComponent<Renderer>();
		}

		private void Update()
		{
			// 実験目的ということで単純化し、不満値は設けずに
			// スペースキーでバーサーカーモードを始動するようにした
			if (Input.GetKeyDown(KeyCode.Space))
			{
				if (IsBerserkerMode)
				{
					StopBerserkerMode();
					randomWalk.StartRandomWalk();
				}
				else
				{
					StartBerserkerMode();
				}
			}
		}

		private void StartBerserkerMode()
		{
			StopBerserkerMode();

			// 視覚的にわかりやすくするため、バーサーカーモード用のマテリアル（赤色）に切り替える
			renderer.material = berserkerModeMaterial;

			// ランダム移動を停止、バーサーカーモードコルーチンを始動する
			randomWalk.StopRandomWalk();
			berserkerModeCoroutine = StartCoroutine(BerserkerModeLogic());
		}

		private void StopBerserkerMode()
		{
			if (berserkerModeCoroutine == null)
			{
				return;
			}

			// ユニットがタイル間を移動中の可能性があるので、次のタイルに到達するまでは待つことにする
			StartCoroutine(WaitForStopBerserkerMode());
		}

		private IEnumerator WaitForStopBerserkerMode()
		{
			if (!IsBerserkerMode)
			{
				yield break;
			}
			needsStopBerserkerMode = true;
			yield return berserkerModeCoroutine;
			berserkerModeCoroutine = null;
			needsStopBerserkerMode = false;

			// 視覚的にわかりやすくするため、徘徊モード用のマテリアル（緑色）に切り替える
			renderer.material = nonBerserkerModeMaterial;

			// ランダム移動を再開
			randomWalk.StartRandomWalk();
		}

		private IEnumerator BerserkerModeLogic()
		{
			while (true)
			{
				// まず、一番近いユニットをターゲットとして選択する
				Transform targetTransform = GameObject.FindGameObjectsWithTag("Target")
					.Select(target => (target.transform, Vector2.Distance(target.transform.position, transform.position)))
					.OrderBy(pair => pair.Item2)
					.Select(pair => pair.transform)
					.FirstOrDefault();

				// ターゲットの上下左右4タイルのうち、一番近いタイルを目的地として採用する
				Vector2Int cellPosition = Vector2Int.RoundToInt(transform.position);
				Vector2Int targetCellPosition = Vector2Int.RoundToInt(targetTransform.position);
				Vector2Int destinationCellPosition = GetNearestNeighborCellPosition(cellPosition, targetCellPosition);

				// パス探索を行う
				// パスが見つからなかった場合はバーサーカーモードを終了する
				if (!moving_From_PositionA_To_PositionB.Find_Path(cellPosition, destinationCellPosition) || (moving_From_PositionA_To_PositionB.Path.Count < 2))
				{
					break;
				}

				// 探索された経路を確認する目的で、シーンビュー上に黄色い線を引く
				for (int i = 1; i < moving_From_PositionA_To_PositionB.Path.Count; i++)
				{
					Debug.DrawLine(
						(Vector2)moving_From_PositionA_To_PositionB.Path[i],
						(Vector2)moving_From_PositionA_To_PositionB.Path[i - 1],
						Color.yellow);
				}

				// 経路上の次のタイルに向かって移動する
				Vector3 nextTilePosition = (Vector3)(Vector2)moving_From_PositionA_To_PositionB.Path[1];
				Vector3 velocity = (nextTilePosition - transform.position) / walkDuration;
				float t = 0.0f;
				while (true)
				{
					transform.Translate(velocity * Time.deltaTime);
					t += Time.deltaTime;
					if (t >= walkDuration)
					{
						break;
					}
					yield return null;
				}
				transform.position = nextTilePosition;

				// バーサーカーモード終了要求が来ていたらループを終える
				if (needsStopBerserkerMode)
				{
					break;
				}
			}
			StopBerserkerMode();
		}

		private static Vector2Int GetNearestNeighborCellPosition(Vector2Int origin, Vector2Int target)
		{
			int deltaX = Mathf.Clamp(origin.x - target.x, -1, 1);
			int deltaY = Mathf.Abs(deltaX) > 0 ? 0 : Mathf.Clamp(origin.y - target.y, -1, 1);
			return new Vector2Int(target.x + deltaX, target.y + deltaY);
		}
	}
}

動きは下図のようになりました。

くの字の経路になってしまい、見苦しくてすみません。一応あれでもチェス盤空間においては最短経路の一つのはずですが、遠回りしているように感じます。「Unity A*(A-Star)アルゴリズム　挙動がおかしくなる」では、経路の評価に使う情報としては浮動小数点数の計算が必要なユークリッド距離よりも、チェス盤ならチェビシェフ距離を使って経路を評価した方がいいんじゃないかと思っていたのですが、こういった見苦しさにつながる可能性は失念していました。

ユークリッド距離を使うと縦横の経路の方が斜めの経路よりも高評価になりますので、下図のように見苦しさが低減するかと思います。こちらの方がお好みでしたらChessboardPathFinderを適宜書き換えてしまってください。

Comments

[退会済みユーザー]

回答ありがとうございます。
ターゲットが動くたびに再計算することはできたのですが、座標が変更されるたびに再計算し移動するせいで、移動するユニットがぐらぐら揺れながら移動するようになってしまいました。

[Bongo]

なるほど...経路を更新した場合、経路の最初の地点は現在のユニットの位置を整数に切り捨てた位置になるわけですから、最初にそこへ向かおうとしてガクガクしてしまうのかもしれませんね。
となると、泥縄的ですみませんがMoving_from_PositionA_to_PositionBスクリプトのMoveの冒頭にある...

foreach (Vector2Int position in pathFinder.Path)
{
Vector2 pos = new Vector3(position.x, position.y);
moveList.Add(pos);
}

を...

foreach (Vector2Int position in pathFinder.Path.Skip(1))
{
Vector2 pos = new Vector3(position.x, position.y);
moveList.Add(pos);
}

としてみるとどうでしょうか。つまり最初の地点は経路から捨ててしまおうと思ったのです（ちなみに、Skipを使うにはスクリプトの冒頭に using System.Linq; が必要になるかと思います）。

これで何かしら改善が見られればいいのですが、ダメならちょっと模擬シーンを作って本腰入れて検討してみたいところです。その場合、スクリーンショットだとかのご質問者さんのシーンの作りがイメージできるような参考情報を追記いただけるとありがたいです。また、ユニットの動き方についてうかがいますが、求めた経路を折れ線の道筋で辿るのではなく、なめらかにカーブを描いて目的地へ向かう方が好ましいでしょうか?

[退会済みユーザー]

スクリプトを編集し、スクリーンショットを追加致しました。
イメージとしては、折れ線の道筋を辿っていくことを考えていました。

[退会済みユーザー]

Unit_RandomWalk.csというスクリプトは、ユニットの半径６マス以内をランダムに移動するだけの単純なのものです。文字数制限があるため、コードは記載しませんでした。

[Bongo]

ちょっと模擬シーンを作って検討してみました。ご参考になれば幸いです。
投稿字数制限はやっかいですね。私もあの回答文の分量でほぼ使い切ってしまっています。ちょっとコードを載せればすぐオーバーしてしまいますし、もう少し緩和していただければうれしいんですがね...

[退会済みユーザー]

回答ありがとうございます。実装することはできたのですが、自分の環境だとバーサーカーモードになったユニットの移動速度が通常よりも速い気がするのですが、気のせいでしょうか？斜め移動だから移動速度が速いように見えるだけなのでしょうか？

[Bongo]

すみません。RandomWalkやBerserkermodeにwalkDurationという名称のフィールドがありますが、これが1タイル移動するのにかかる時間を表しており、提示しましたコードにあるようにデフォルト値はRandomWalkが0.5秒、Berserkermodeが0.25秒となっています。
バーサーカーモードだと怒りながら早歩きで獲物に向かっていくのかな...と思ってそうしたのですが、バーサーカーモードの動きが速すぎると、肝心の「動く獲物に対してその都度経路を再計算して接近している」ということを図示しにくかったため、インスペクター上でBerserkermodeのwalkDurationを1秒に変更したのを申し上げ忘れていました。
ご質問者さんの場合はここの設定はどうなっていますでしょうか?

[退会済みユーザー]

walkDurationという変数が１タイル移動するのに必要な時間を意味していたのですね。分かりました。丁寧な回答、ありがとうございました。