[Unity] 십자 타일에서 한 칸씩 이동하는데 대각선으로 움직일 수도 있다고?
A* 알고리즘으로 탐색한 경로를 따라 플레이어가 한 칸씩 이동하는 기능을 구현했다.
오늘 진행한 여러 실습 중 하나는 플레이어가 여러 칸을 이동하는 도중 다른 위치를 클릭하면, 기존 목적지 대신 새롭게 클릭한 위치로 이동하도록 만드는 것이었다.
이를 구현하는 방법은 여러 가지가 있을 것이다. 새로운 메서드를 만들어 이동 중 목적지를 변경하도록 처리할 수도 있었지만, 나는 조금 다른 방식으로 접근해 보고 싶었다.
이미 배운 문법과 기능들을 최대한 활용해 보고 싶었고, 직접 코드를 구성하면서 각 코드가 어떤 순서로 실행되고 서로 어떻게 연결되는지 더 정확하게 이해하고 싶었기 때문이다.
마치 레고를 분해하고 다시 조립하듯, 기존에 작성한 코드의 실행 순서를 바꾸고 필요한 부분을 수정하면서 원하는 기능을 구현하고자 했다.
그렇게 완성한 코드를 오준환 강사님께 리뷰받았고, 그 과정에서 내가 미처 생각하지 못했던 부분을 발견하게 되었다.
이번 글에서는 내가 작성한 방식과 강사님께서 작성하신 방식을 비교하고, 그 과정에서 배운 점을 정리해 보려고 한다.
1. 내가 작성한 방식
먼저 내가 작성한 Update()의 이동 관련 코드이다.
기존에 작성한 CoMoveOneStep()을 그대로 활용하면서 여러 칸을 이동하는 도중 새로운 위치를 클릭하면 해당 위치로 목적지를 변경하도록 구현했다.
Update() 코드
if (currentTile == null)
{
return;
}
if (Input.GetMouseButtonDown(1))
{
int tileId = stage.ScreenPosTileId(Input.mousePosition);
if (tileId < 0 || tileId >= stage.Map.tiles.Length)
{
return;
}
Tile targetTile = stage.Map.tiles[tileId];
if (!targetTile.CanMove || targetTile == currentTile)
{
return;
}
int startTileId;
if (isMoving)
{
startTileId = endTile.id;
}
else
{
startTileId = currentTile.id;
}
path = stage.PathFindAStar(startTileId, targetTile.id);
isFollowingPath = path != null && path.Count > 1;
}
if (isMoving)
{
return;
}
if (isFollowingPath)
{
for (int i = 0; i < path.Count - 1; i++)
{
if (path[i].id != currentTile.id)
{
continue;
}
endTile = path[i + 1];
StartCoroutine(CoMoveOneStep(endTile));
return;
}
isFollowingPath = false;
}
CoMoveOneStep() 코드
실제 한 칸 이동은 기존에 작성해 두었던 CoMoveOneStep() 코루틴을 사용했다.
private IEnumerator CoMoveOneStep(Tile next)
{
isMoving = true;
animator.speed = 1f;
Vector3 startPos = transform.position;
Vector3 targetPos = stage.GetTilePos(next.id);
float moveDuration = Vector3.Distance(startPos, targetPos) / moveSpeed;
float elapsed = 0f;
while (elapsed < moveDuration)
{
elapsed += Time.deltaTime;
float t = elapsed / moveDuration;
transform.position = Vector3.Lerp(startPos, targetPos, t);
yield return null;
}
transform.position = targetPos;
currentTile = next;
animator.speed = 0f;
stage.OnTileVisited(currentTile.id);
isMoving = false;
}
내가 생각한 구현 과정
처음에는 새로운 목적지를 클릭했을 때 이동을 어떻게 변경해야 할지 고민했다.
기존에는 CoMoveOneStep()을 통해 한 칸을 이동할 수 있었으므로, 이것을 여러 번 실행하면 여러 칸을 이동할 수 있다고 생각했다.
그런데 여러 칸을 이동하는 도중 새로운 위치를 클릭하면 어떻게 해야 할까?
나는 현재 진행 중인 한 칸의 이동은 마무리하고, 그다음부터 새로운 목적지로 이동하도록 만드는 방식을 생각했다. 플레이어가 가는 도중에 뒷걸음질 순간이동처럼 이동할거라 생각했기 때문이다.
이를 위해 이동 중인지 확인하는 isMoving과 경로를 따라 이동 중인지 확인하는 isFollowingPath를 활용했다.
① 새로운 목적지를 클릭했을 때
int startTileId;
if (isMoving)
{
startTileId = endTile.id;
}
else
{
startTileId = currentTile.id;
}
여기가 가장 먼저 고민했던 부분이다.
플레이어가 이동 중이 아니라면 현재 위치인 currentTile에서 새로운 경로를 탐색하면 된다.
하지만 이동 중이라면 이야기가 달라진다.
CoMoveOneStep()에서 currentTile은 한 칸 이동이 완료된 다음에 갱신된다. 따라서 이동 도중에는 플레이어가 다음 타일을 향해 움직이고 있어도 currentTile은 이전 타일을 가리키고 있다.
그래서 이동 중 새로운 목적지를 클릭했다면 currentTile이 아니라 현재 이동하고 있는 타일의 도착 지점인 endTile을 새로운 경로의 시작점으로 사용했다.
이렇게 하면 현재 진행 중인 한 칸의 이동을 끝낸 뒤 새로운 목적지로 이동할 수 있다고 생각했다.
② 새로운 경로를 저장
path = stage.PathFindAStar(startTileId, targetTile.id);
isFollowingPath = path != null && path.Count > 1;
시작점과 새로운 목적지를 기준으로 A* 경로 탐색을 실행한다.
그리고 경로가 존재하고, 이동할 다음 타일이 있다면 isFollowingPath를 true로 설정한다.
이렇게 해서 기존 경로를 새로운 경로로 교체하도록 했다.
③ 이동 중이라면 기다리기
if (isMoving)
{
return;
}
새로운 경로를 구했다고 해서 바로 이동을 시작하면 기존에 실행 중인 코루틴과 새로운 코루틴이 동시에 플레이어의 위치를 변경할 수 있다.
그래서 isMoving이 true라면 현재 Update()를 종료하도록 했다.
현재 실행 중인 CoMoveOneStep()이 끝나면 isMoving이 false가 되고, 그때부터 새로운 경로를 따라 이동할 수 있다.
④ 경로에서 현재 위치를 찾아 다음 타일로 이동
if (isFollowingPath)
{
for (int i = 0; i < path.Count - 1; i++)
{
if (path[i].id != currentTile.id)
{
continue;
}
endTile = path[i + 1];
StartCoroutine(CoMoveOneStep(endTile));
return;
}
isFollowingPath = false;
}
먼저 isFollowingPath를 확인하여 현재 따라갈 경로가 있는지 판단한다.
if (isFollowingPath)
true라면 A*로 탐색한 경로를 따라 다음 타일로 이동해야 하므로 내부 코드를 실행한다.
for (int i = 0; i < path.Count - 1; i++)
path에 저장된 타일들을 처음부터 순회한다.
여기서 path.Count - 1까지만 검사하는 이유는 다음 이동할 타일을 path[i + 1]로 가져오기 때문이다.
마지막 인덱스까지 검사하면 path[i + 1]이 리스트의 범위를 벗어날 수 있으므로, 다음 타일이 존재하는 위치까지만 확인하도록 했다.
if (path[i].id != currentTile.id)
{
continue;
}
현재 검사 중인 path[i]가 플레이어의 현재 위치인 currentTile과 일치하는지 확인한다.
일치하지 않는다면 continue를 통해 이번 반복을 건너뛰고 다음 인덱스를 검사한다.
즉 경로에서 현재 플레이어가 위치한 타일을 찾을 때까지 반복하는 것이다.
endTile = path[i + 1];
현재 위치를 찾았다면 그다음 타일을 endTile에 저장한다.
endTile은 이번 한 칸 이동의 도착 지점으로, 플레이어가 이동하는 동안 새로운 목적지를 클릭했을 때 다음 경로의 시작점으로도 활용된다.
StartCoroutine(CoMoveOneStep(endTile));
return;
CoMoveOneStep()을 실행하여 다음 타일로 이동하기 시작한다.
여기서 StartCoroutine()은 코루틴을 시작하지만, 코루틴이 끝날 때까지 Update()의 실행을 기다리지는 않는다.
따라서 return을 사용하여 현재 Update()를 종료한다.
이렇게 하면 이번에는 한 칸 이동만 시작하고, 다음 프레임부터는 isMoving 상태에 따라 추가 이동을 시작하지 않도록 처리할 수 있다.
isFollowingPath = false;
반복문에서 현재 위치와 일치하는 타일을 찾지 못했거나, 현재 위치가 경로의 마지막 타일이어서 다음 이동을 시작할 수 없다면 이 코드가 실행된다.
더 이상 따라갈 다음 타일이 없다고 판단하여 경로 추적을 종료하는 것이다.
결과적으로 이 코드는 경로에서 현재 위치를 찾고 → 다음 타일을 결정하고 → 한 칸 이동을 시작한 다음 → 이동이 완료되면 다시 다음 타일을 찾는 방식으로 동작한다.
CoMoveOneStep()에서 이동이 완료되면 currentTile이 갱신되고 isMoving이 false가 되므로, 다음 Update()에서는 갱신된 위치를 기준으로 같은 과정을 반복한다.
내가 이렇게 작성한 이유
가장 큰 이유는 내가 갖고 있는 것들을 극한으로 활용해 보고 싶었기 때문이다.
이미 만들어진 코드를 그대로 사용하기보다는 내가 생각한 방식으로 재구현하고, 그 코드가 실제로 어떻게 실행되는지 이해하고 싶었다.
그래서 그림판에 타일 번호를 하나씩 적어 보고, 현재 타일이 바뀔 때 반복문이 어떻게 실행되는지도 직접 그려봤다.
예를 들어 다음과 같은 경로가 있다고 가정했다.
path = [21, 22, 23, 33, 43]
21 → 22 → 23
↓
33
↓
43
처음에는 currentTile이 21이므로 22로 이동한다.
이동이 완료되면 currentTile은 22가 되고, 다음에는 반복문에서 22를 찾아 23으로 이동한다.
이 과정을 반복하면 목적지까지 이동할 수 있다.
이번 학습에서는 직접 구현한 코드의 흐름을 이해하는 것에 더 의미를 두었다.
2. 오준환 강사님의 방식
강사님께서 작성하신 방식은 내가 작성한 코드와 접근 방법이 달랐다.
먼저 Update()에서 마우스 클릭을 처리하는 부분이다.
if (Input.GetMouseButtonDown(1))
{
int tileId = stage.ScreenPosTileId(Input.mousePosition);
if (tileId < 0 || tileId >= stage.Map.tiles.Length)
return;
Tile targetTile = stage.Map.tiles[tileId];
if (!targetTile.CanMove)
return;
pendingTarget = targetTile;
if (!isMoving)
StartCoroutine(CoMovePlayer());
}
내 방식에서는 경로를 구한 다음 Update()에서 현재 위치를 계속 확인했다.
반면 강사님 방식에서는 클릭한 목적지를 pendingTarget에 저장하고, 이동 중이 아니라면 CoMovePlayer() 코루틴을 실행한다.
이동 과정은 다음 코루틴에서 처리한다.
private IEnumerator CoMovePlayer()
{
isMoving = true;
animator.speed = 1f;
List<Tile> movePath = null;
Tile pathTarget = null;
int pathIndex = 0;
while (pendingTarget != currentTile)
{
if (pathTarget != pendingTarget)
{
movePath = stage.PathFindAStar(
currentTile.id,
pendingTarget.id
);
pathTarget = pendingTarget;
pathIndex = 1;
}
if (movePath == null || pathIndex >= movePath.Count)
break;
yield return CoMoveOneStep(movePath[pathIndex++]);
}
animator.speed = 0f;
isMoving = false;
}
여기서는 pathIndex를 사용한다.
내 방식처럼 매번 현재 타일을 찾아 순회하는 것이 아니라, 현재 이동해야 할 경로의 인덱스를 저장하고 하나씩 증가시키는 방식이다.
yield return CoMoveOneStep(movePath[pathIndex++]);
pathIndex++를 통해 다음 이동 위치를 가져온 뒤 인덱스를 증가시킨다.
그리고 yield return을 사용해 한 칸 이동하는 코루틴이 끝날 때까지 기다린 다음 다음 이동을 진행한다.
또한 이동 중 새로운 목적지를 클릭하면 pendingTarget이 변경된다. 현재 이동 중인 한 칸을 완료한 뒤 pathTarget과 pendingTarget을 비교하여 필요한 경우 A* 경로를 다시 계산하도록 구성되어 있다.
강사님 방식은 하나의 코루틴 안에서 목적지 변경과 경로 이동을 관리하는 방식이었다.
3. 두 방식의 차이
| 구분 | 내가 작성한 방식 | 강사님 방식 |
|---|---|---|
| 이동 관리 | Update()에서 처리 | CoMovePlayer()에서 처리 |
| 경로 위치 확인 | for문으로 현재 타일 검색 | pathIndex 사용 |
| 한 칸 이동 | StartCoroutine() | yield return |
| 경로 진행 | 이동 완료 후 다음 Update에서 검색 | 코루틴 내부에서 순차 진행 |
| 목적지 변경 | 이동 중 끝 타일 기준으로 새 경로 계산 | pendingTarget 변경 후 필요 시 재탐색 |
두 방식 모두 A*가 반환한 경로를 따라 한 칸씩 이동한다는 목적은 같다.
다만 내가 작성한 방식은 매번 현재 위치를 찾아 다음 타일을 결정하고, 강사님 방식은 경로 인덱스를 관리하면서 코루틴 내부에서 이동을 이어간다는 차이가 있다.
강사님 코드를 보면서 이렇게 해야 취업 할 수 있구나를 자주 느낀다.
4. 어떻게 대각선으로 움직일 수 있는 걸까?
오준환 강사님께 내가 작성한 코드를 보여드리고 리뷰를 받았다.
리뷰를 받는 과정에서도 먼저 생각을 정제하고 정리하는 습관이 필요할 것 같다고 느꼈다. 이전에 비해 설명을 조금 더 일목요연하게 할 수 있게 되었지만, 순간적으로 내 사고의 흐름을 놓치는 경우가 여전히 있었다.
아무튼 리뷰 과정에서 강사님께서 간혹 대각선으로 움직일 수도 있을 것 같다고 말씀하셨다.
처음에는 '엥? 내가 잘못 짰나?' 싶었다. 사실 처음 설명을 들었을 때는 반 정도밖에 이해하지 못했다.
나머지 반을 채우기 위해 코드를 다시 살펴보고, 노트에 타일 번호를 하나씩 적어 가며 플레이어가 어떤 순서로 이동하는지 직접 그려봤다. 나름대로 여러 경우를 생각했고, 논리적으로 문제가 없다고 판단했다.
그래서 집에 가기 전, 내가 생각한 이동 과정을 다시 설명드리면서 여쭤봤다.
"A* 알고리즘에서 맨해튼 거리를 사용했는데, 어떻게 대각선으로 이동할 수 있는 건가요?"
그러자 강사님께서 직접 그림을 그려주시면서 대각선으로 이동할 수 있는 경우를 찬찬히 설명해 주셨다.
강사님께서 설명해 주신 부분은 경로의 모서리를 돌아갈 때 대각선으로 이동할 수 있다는 가능성이었다.
내가 놓친 부분은 무엇일까?
내가 작성한 코드를 다시 살펴보면 다음과 같다.
if (path[i].id != currentTile.id)
{
continue;
}
endTile = path[i + 1];
StartCoroutine(CoMoveOneStep(endTile));
나는 path[i + 1]이 당연히 현재 위치의 상하좌우 중 하나일 것이라고 생각했다.
예를 들어 가로 20칸인 맵에서 다음과 같이 모서리를 돌아가는 경로가 있다고 가정해 보자.
path = [21, 22, 42]
[21] → [22]
↓
[42]
내가 의도한 이동은 21번에서 22번으로, 다시 42번으로 이동하는 것이다.
실제로 위 경로가 그대로 유지된다면 코드도 21 → 22 → 42 순서로 이동한다.
그런데 여기서 한 가지 생각해 볼 부분이 있다.
endTile = path[i + 1];
이 코드는 현재 타일을 찾은 다음 경로의 다음 타일을 가져올 뿐 그 타일이 실제로 현재 위치의 상하좌우에 있는지는 검사하지 않는다.
만약 현재 위치가 21번인데 다음 이동 목표가 42번으로 지정된다면 어떻게 될까?
path = [21, 42]
[21] [22]
↘
[42]
21번과 42번은 행과 열이 각각 한 칸씩 차이 나는 대각선 위치이므로, 플레이어는 42번을 향해 대각선으로 이동하게 된다.
다만 정상적인 4방향 A* 경로라면 [21, 22, 42]에서 22번을 건너뛰어 [21, 42]로 바뀌지는 않는다.
따라서 단순히 모서리를 돈다는 이유만으로 대각선 이동이 발생하는 것은 아니다. A*가 어떤 타일을 인접 노드로 판단하는지, 이동 도중 목적지를 변경했을 때 경로가 어떻게 갱신되는지를 함께 확인해야 한다.
내가 맨해튼 거리를 사용했다는 점도 다시 생각해 보게 되었다.
맨해튼 거리는 목적지까지의 거리를 추정하는 방식이지, 이동 가능한 방향을 직접 제한하는 조건은 아니다. 실제 이동 방향은 A*에서 연결된 인접 노드에 따라 달라진다.
결국 내가 작성한 코드는 A*가 반환한 경로에서 다음 타일로 이동하는 코드이지, 상하좌우 이동만을 직접 보장하는 코드는 아니었다.
느낀 점
강사님의 설명을 듣고 이해한 뒤에도 집으로 돌아오는 동안 계속 생각해 봤다.
나는 한 칸씩 이동하도록 구현했으니 당연히 상하좌우로 움직일 거라고 생각했다.
하지만 한 칸씩 이동한다는 것이 반드시 상하좌우 이동을 의미하는 것은 아니었다.
내가 생각한 경우에서 정상적으로 동작한다고 해서 모든 상황을 검증한 것은 아니었다.
노트에 숫자를 하나씩 적어 가며 확인했지만, 결국 내가 떠올린 상황 안에서만 코드를 검증하고 있었던 것이다.
그런데 강사님은 내가 미처 생각하지 못했던 가능성을 바로 떠올리셨다.
이런 경우가 머릿속에서 바로 떠오르는 걸 보면 가끔 오준환 강사님은 터미네이터? AI? 가 아닐까 싶다.
이번에는 내가 가진 지식과 배운 문법들을 최대한 활용해 보고 싶어서 조금 돌아가는 방식으로 코드를 작성했다. 그 과정에서 반복문과 코루틴이 실제로 어떻게 동작하는지 더 자세하게 생각해 볼 수 있었다.
앞으로도 처음부터 가장 짧고 효율적인 코드만 작성하려고 하기보다는 내가 생각한 방식으로 직접 구현해 보고, 그 과정에서 발견한 문제를 개선하면서 이해의 폭을 넓혀가고 싶다. 이 방식이 오준환 강사님이 말씀하신 '더 나은 직관'을 갖는 방법이 아닐까 싶다.
비효율적이기에 효율적이다.
예전에 순수하게 컴퓨터 공학 공부를 하면서 느꼈던 문구이자 지금의 학습 과정에 잘 어울리는 말인 것 같다.




