gbleem 님의 블로그

시간복잡도 줄이기 2) 하나 고정하기

gbleem — Tue, 30 Sep 2025 16:49:59 +0900

1. 하나 고정하고 나머지 값을 통해 찾기

배열에서 세가지 값의 합을 구하는 등의 작업을 할 때, 하나의 값을 고정시켜두고 나머지 값들만 투포인터를 통해서 계산하기

2. 문제

https://www.acmicpc.net/problem/2473

이 문제는"중간에서 만나기"를 쓰면 추가 공간이 필요하여 메모리가 터진다.
n = 5000이기 때문에 n^2은 25,000,000이 되고, 여기서 long long값과 인덱스 2개를 int로 저장하면
- 25,000,000 * (8 + 4 + 4) = 400,000,000
- 400MB 메모리 필요하므로 메모리 초과가 될 것이다.

풀이

#include <iostream>
#include <vector>
#include <algorithm>
#include <climits>
using namespace std;

int n;
vector<long long> vec;
long long minValue = LLONG_MAX;
vector<long long> answer;

void Print()
{
	sort(answer.begin(), answer.end());

	for (const auto& a : answer)
	{
		cout << a << " ";
	}
}

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> n;

	for (int i = 0; i < n; ++i)
	{
		int num;
		cin >> num;
		vec.push_back(num);
	}

	sort(vec.begin(), vec.end());

	for (int i = 0; i < n - 2; ++i)
	{
		int l = i + 1;
		int r = n - 1;

		while (l < r)
		{
			long long temp = vec[i] + vec[l] + vec[r];

			if (abs(temp) < minValue)
			{
				minValue = abs(temp);

				answer.clear();
				answer.push_back(vec[i]);
				answer.push_back(vec[l]);
				answer.push_back(vec[r]);
			}

			if (temp < 0)
				l++;
			else if (temp > 0)
				r--;
			else
			{
				Print();
				return 0;
			}
		}
	}
	Print();
}

시간복잡도 줄이기 1) 중간에서 만나기 (+이분탐색)

gbleem — Wed, 24 Sep 2025 00:29:53 +0900

1. 중간에서 만나기

알고리즘의 전체 탐색 범위를 반으로 나누어, 양쪽에서 동시에 탐색을 시작해 중간에서 만나는 방식으로 시간 복잡도를 줄이는 기법
예시
- 00000000~99999999 비밀번호 풀기
  - 앞의 4자리와 뒤의 4자리를 따로 계산한 결과 A와 B를 합쳐서 정답이 되는지 확인하기
  - 10^8의 연산을 10^4 * 2 의 연산으로 줄여준다
- A+B+C+D = 0 찾기
  - A+B = -(C+D) 로 계산하기
  - 모든 조합의 합을 계산 : n^2
  - C+D를 정렬한 후 A+B를 순환하면서 이분탐색을 하기 : O(N^2logN)
    - N^2사이즈의 A+B 배열을 돌면서 O(N^2)
    - N^2사이즈의 배열을 이진탐색 O(logN^2) 하기 -> O(N^2logN^2)
!중요!
- 메모리 제한을 항상 생각하고 쓰기
- 이 방식은 메모리를 많이 사용하게 된다!

2. 문제

https://www.acmicpc.net/problem/7453

풀이

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;

int n;
vector<int> board[4];
vector<int> sumA;
vector<int> sumB;
long long answer = 0;

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> n;

	for (int i = 0; i < n; ++i)
	{
		int a, b, c, d;
		cin >> a >> b >> c >> d;

		board[0].push_back(a);
		board[1].push_back(b);
		board[2].push_back(c);
		board[3].push_back(d);
	}

	for (int i = 0; i < n; ++i)
	{
		for (int j = 0; j < n; ++j)
		{
			sumA.push_back(board[0][i] + board[1][j]);
			sumB.push_back(board[2][i] + board[3][j]);
		}
	}

	sort(sumB.begin(), sumB.end());

	for (const auto& a : sumA)
	{
		int target = -a;

		int st = lower_bound(sumB.begin(), sumB.end(), target) - sumB.begin();
		int en = upper_bound(sumB.begin(), sumB.end(), target) - sumB.begin();

		answer += (long long)(en - st);
	}

	cout << answer;
}

트라이

gbleem — Mon, 8 Sep 2025 18:41:51 +0900

1. 개념

문자열을 효율적으로 처리하기 위한 트리 자료구조

삽입 삭제 탐색에 있어서 O(|S|) 시간이 소요
그러나 메모리는 최대 4*글자의 종류 만큼 차지하므로 메모리 효율은 좋지 않다.
이론적인 시간 복잡도와 달리 실제로는 트라이가 해시나 이진 검색 트리에 비해 느리다.
- 그러나 이 특징을 사용해야하는 문제가 있다.
- 문자열의 접두사 검색 등과 같은 느낌

2. 구현

코드

#include <iostream>
using namespace std;

const int ROOT = 1;
int unused = 2; //새로 추가할 정점
const int MX = 10000 * 500 + 5; //최대 등장 가능한 글자 수 -> 최대 500인 문자열이 10000개 들어온 경우
bool chk[MX];
int nxt[MX][26]; // 각 정점에서 자식 정점의 번호 (가능한 문자가 소문자인 경우)

int c2i(char c)
{
	return c - 'A';
}

void insert(string& s)
{
	int cur = ROOT;
	for (auto c : s)
	{
		if (nxt[cur][c2i(c)] == -1)
			nxt[cur][c2i(c)] = unused++;
		cur = nxt[cur][c2i(c)];
	}
	chk[cur] = true;
}

bool find(string& s)
{
	int cur = ROOT;
	for (auto c : s)
	{
		if (nxt[cur][c2i(c)] == -1)
			return false;
		cur = nxt[cur][c2i(c)];
	}
	return chk[cur];
}

void erase(string& s)
{
	int cur = ROOT;
	for (auto c : s)
	{
		if (nxt[cur][c2i(c)] == -1)
			return;
		cur = nxt[cur][c2i(c)];
	}
	chk[cur] = false;
}

int main()
{
	for (int i = 0; i < MX; ++i)
		fill(nxt[i], nxt[i] + 26, -1);

	///
}

3. 문제

boj 14426

참고)

https://blog.encrypted.gg/1059

[실전 알고리즘] 0x1F강 - 트라이

안녕하세요, 드디어 마지막 강이라니 가슴이 웅장해집니다. 마지막인만큼 난이도도 끝판왕일 수 있지만 개인적으로는 꽤 좋아하는 알고리즘 중 하나여서 같이 즐거운 마음으로 배워봅시다. 아

blog.encrypted.gg

위상정렬

gbleem — Sun, 7 Sep 2025 01:52:06 +0900

1. 개념

방향 그래프에서 간선으로 주어진 정점 간 선후관계를 위배하지 않도록 나열하는 정렬을 말한다.

예를 들어, 교과 이수 제도가 있다.
특정 과목을 듣기 위해서 선수과목이 있는 그런 형태를 말한다.

주의할 점

같은 그래프에서 여러 가지의 위상 정렬이 있을 수는 있다.
단, 그래프의 순환이 있는 경우는 위상정렬이 될 수 없다.
위상 정렬은 사이클이 없는 방향 그래프(DAG) 에서만 정의된다.

2. 구현

참고

indegree : 자신에게 들어오는 간선의 수

동작 방식

모든 간선을 순환하여 indegree 테이블 채우기
indegree가 0인 정점들을 queue에 넣기
queue에서 pop을 통해 위상 정렬 결과에 추가
해당 정점으로부터 연결된 모든 정점의 indegree값을 1감소, 만약 이 때 indegree가 0이라면 정점을 queue에 추가
queue가 빌 때 까지 반복

그림

코드

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

vector<int> adj[10];
int indegree[10];
int n;

int main()
{
	queue<int> q;
	vector<int> result;

	for (int i = 1; i <= n; ++i)
	{
		if (indegree[i] == 0)
			q.push(i);
	}
	while (!q.empty())
	{
		int cur = q.front();
		q.pop();
		result.push_back(cur);
		
		for (int nxt : adj[cur])
		{
			indegree[nxt]--;
			if (indegree[nxt] == 0)
				q.push(nxt);
		}
	}
	if (result.size() != n)
		cout << "cycle";
	else
	{
		for (const auto& r : result)
		{
			cout << r << " ";
		}
	}
}

3. 문제

boj 2252 : 기본 위상정렬

#include <iostream>
#include <queue>
#include <vector>
using namespace std;

int n, m;
vector<int> adj[32'002];
int deg[32'002];
vector<int> answer;

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> n >> m;


	while (m--)
	{
		int a, b;
		cin >> a >> b;
		adj[a].push_back(b); //a가 b앞
		deg[b]++; //b는 a가 필요해
	}
	queue<int>q;
	for (int i = 1; i <= n; ++i)
	{
		if (deg[i] == 0)
			q.push(i);
	}

	while (!q.empty())
	{
		int cur = q.front();
		q.pop();
		answer.push_back(cur);

		for (int nxt : adj[cur])
		{
			deg[nxt]--;
			if (deg[nxt] == 0)
				q.push(nxt);
		}
	}

	for (const auto& a : answer)
	{
		cout << a << " ";
	}
}

boj 1005 : 위상정렬 + DP

#include <iostream>
#include <queue>
#include <vector>
#include <set>
using namespace std;

int t, n, k, w;
vector<int> adj[1002];
int deg[1002];
int D[1002];
int dp[1002];
set<int> ans;
int answer = 0;

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> t;

	while (t--)
	{
		for (int i = 0; i < 1002; ++i)
			adj[i].clear();
		fill(D, D + 1002, 0);
		fill(deg, deg + 1002, 0);
		fill(dp, dp + 1002, 0);
		answer = 0;

		cin >> n >> k;
		
		for (int i = 1; i <= n; ++i)
		{
			cin >> D[i];
		}

		for (int i = 0; i < k; ++i)
		{
			int x, y;
			cin >> x >> y;
			adj[x].push_back(y);
			deg[y]++;
		}
		cin >> w;

		queue<int> q;

		for (int i = 1; i <= n; ++i)
		{
			if (deg[i] == 0)
			{
				q.push(i);
				dp[i] = D[i];
			}
		}

		while (!q.empty())
		{
			int cur = q.front();
			q.pop();

			for (int nxt : adj[cur])
			{
				dp[nxt] = max(dp[nxt], dp[cur] + D[nxt]);
				deg[nxt]--;
				if (deg[nxt] == 0)
					q.push(nxt);
			}
		}

		cout << dp[w] << "\n";
	}
}

참고)

https://blog.encrypted.gg/1020

[실전 알고리즘] 0x1A강 - 위상 정렬

안녕하세요, 이번 시간에는 위상 정렬을 다뤄보도록 하겠습니다. 위상 정렬이 무엇인지도 소개해드릴거고 구현과 연습 문제도 다룰 예정입니다. 위상 정렬의 본격적인 정의를 배워보기 전에 실

blog.encrypted.gg

플로이드

gbleem — Fri, 8 Aug 2025 16:34:14 +0900

1. 플로이드 알고리즘

모든 정점 쌍 사이의 최단 거리를 구하는 알고리즘

방향 그래프나 무방향 그래프 모두 상관없음
간선이 음수여도 동작함, 단 음수 사이클은 없어야 함
시간 복잡도는 O(V^3)

왜 쓸까?

예를 들어 정점이 100개 정도일 때 쓸만함 -> 코드가 쉬우니까
모든 정점에 대한 거리를 알고 싶을 때
경유지를 고려해야 할 때 (다익스트라 같은 경우는 A->Z 까지의 최단 거리만 구하기 때문)
또한 음수 가중치가 있는 경우..

2. 동작 방식

먼저 테이블을 만들어 두고, 각 정점에서 인접한 정점까지의 거리만 업데이트하여 최단 거리 테이블을 만든다.

지금까지 적어둔 값은 어떠한 정점을 거치지 않았을 때의 모습이다. 이제부터는 특정 정점을 거쳐가면서 더 짧은 경로가 있다면 업데이트 해주면 된다.
아래 모습은 정점 1은 거쳐가는 경우 업데이트된 최단 거리 테이블의 모습이다

위에서 한 방식을 모든 정점을 다 돌면서 수행하면 된다.
코드로 생각해보면 업데이트 하는 부분에 있어서는 dp 방식과 유사한 비교를 하게 되는데, s에서 t로 가는동안 n을 지난다고 했을때 아래와 같은 코드를 통해 업데이트 하게 된다.

DP[s][t] = min(DP[s][t], DP[s][n] + DP[n][t]);

모든 정점에 대해서 V 단계에 걸쳐서 갱신이 이루어지고, 각 단계마다 V^2개의 DP 값을 비교하기 때문에 시간 복잡도는 O(V^3) 이 된다.

3. 코드

주의점

두 거리 덧셈에 있어서 int overflow 방지를 위해서 INF값 설정하기
플로이드는 대충 정점 1000개까지는 해볼만 하다...
비교하는 부분에서 min 함수를 쓰기보다 if문으로 체크하는 방식으로 바꾸면 좀 더 효율적이다
- 이유는 대입을 매번 하는 것을 막을 수 있기 때문이다.
boj 11404 풀이

#include <iostream>
#include <climits>
using namespace std;

int n, m;
int arr[102][102];
const int INF = 0x3f3f3f3f;

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> n;
	cin >> m;
	
	for (int i = 1; i <= n; ++i)
		fill(arr[i], arr[i] + 1 + n, INF);

	for (int i = 1; i <= n; ++i)
	{
		arr[i][i] = 0;
	}

	for (int i = 0; i < m; ++i)
	{
		int a, b, c;
		cin >> a >> b >> c;
		arr[a][b] = min(arr[a][b], c);
	}

	for (int i = 1; i <= n; ++i)
	{
		for (int j = 1; j <= n; ++j)
		{
			for (int k = 1; k <= n; ++k)
			{
				arr[j][k] = min(arr[j][k], arr[j][i] + arr[i][k]);
			}
		}
	}

	for (int i = 1; i <= n; ++i)
	{
		for (int j = 1; j <= n; ++j)
		{
			if (arr[i][j] == INF)
				cout << "0 ";
			else
				cout << arr[i][j] << " ";
		}
		cout << "\n";
	}
}

추가) 사이클 구하기 (boj 1956)

#include <iostream>
using namespace std;

int board[402][402];
const int INF = 0x3f3f3f3f;
int v, e;
int answer = INF;

int main()
{
	ios::sync_with_stdio(0);
	cin.tie(0);

	cin >> v >> e;
	for (int i = 1; i <= v; ++i)
		fill(board[i] + 1, board[i] + 1 + v, INF);

	for (int i = 1; i <= v; ++i)
		board[i][i] = 0;

	for (int i = 0; i < e; ++i)
	{
		int a, b, c;
		cin >> a >> b >> c;
		board[a][b] = c;
	}

	for (int i = 1; i <= v; ++i)
	{
		for (int j = 1; j <= v; ++j)
		{
			for (int k = 1; k <= v; ++k)
			{
				board[j][k] = min(board[j][k], board[j][i] + board[i][k]);
			}
		}
	}

	//사이클 계산
	for (int i = 1; i <= v; ++i)
	{
		for (int j = i + 1; j <= v; ++j)
		{
			answer = min(answer, board[i][j] + board[j][i]);
		}
	}

	if (answer == INF)
		cout << -1;
	else
		cout << answer;
}

UE5 Issues - 파괴되는 Mesh

gbleem — Wed, 18 Jun 2025 20:09:29 +0900

보스 레벨에서 플레이어들이 사용하는 다리 Mesh가 있는데, 이것을 파괴하는 시스템을 개발하게 되었다.

1. 고민

처음에는 해당 기획을 듣고 여러 방식을 떠올리게 되었다.

Chaos
Physics Constraint
etc...

개발하기 전 가장 중요하게 생각했던 부분은 "부서진 이후의 결과물"에 대한 고민이었다.

파괴된 이후의 Mesh가 사라지도록 하여 게임에 영향을 미치지 않도록 할 것인가
파괴된 이후의 Mesh가 이후 게임에 영향을 미치도록 할 것인가

이 부분은 게임 플레이에 영향을 미칠 수 있는 부분이라고 생각하여 최대한 게임 플레이에 있어서 지장을 주지 않는 방향으로 생각하고 개발을 하였다.

다음으로는 고민한 내용은 얼마나 예쁘게 부술 수 있는가에 대한 내용이었다.

현재 팀에는 배경 모델링을 담당해주시는 분이 있었기 때문에 카오스로 부수기보다는 부서져 있는 에셋 자체를 쓰는 것이 더 좋다는 생각이 들었다.
다리 메시가 뼈모양의 다리였고, 이 경우 뼈 마디마디가 부서지는 것이 자연스럽다는 생각이 들었기 때문이다.
돌이나 기둥 같은 에셋이었다면, 매번 다르게 부서지는 것이 더 그럴듯 해 보이겠지만...

결론적으로 아래와 같이 각각의 조각으로 구성된 메시 에셋을 받아서 작업을 시작하게 되었다.

2. 여러 시도들

다리 메시 에셋을 받기 전, 카오스 시스템에 대한 테스트를 해보았다.

가장 큰 문제점은 부서진 이후의 위치가 동기화 되지 않는다는 문제가 있었다.
이걸 해결하는 방법을 찾아보긴 했지만, Chaos 시스템에 익숙하지 않은 상태에서 너무 오랜 시간을 쏟아버리는 것은 좋지 않다고 판단했다.
특히 위치 동기화가 제대로 되지 않은 경우, 부서진 이후 게임 내에서 사라지지 않도록 구현하게 된다면 문제가 되기 때문에 다른 방법을 선택하게 되었다.

새롭게 시도한 방식이 Physics Constraint를 사용한 내용이다.

언리얼이 가지고 있는 기능으로 로프 시스템이나 흔들다리와 같은 시스템을 개발할 때 주로 사용하는 컴포넌트이다
아래 사진처럼 각 mesh를 연결하여 두고, 특정 힘을 가했을 때 해당 연결을 끊어주는 식으로 구현하려고 했다.
그러나 모든 제한조건을 잠궈두어도, 약간 용수철처럼 통통거리는 느낌이 나서 뼈 모양의 다리와는 어울리지 않는다고 느껴졌고,
이 방식 역시 새롭게 사용하는 방식이다 보니 시간내에 원하는 퀄리티의 결과물을 내기 어려울 것으로 판단되었다.

마지막으로 가장 단순한 방식으로 개발을 하게 되었다.

다리를 구성하는 메시 한 조각을 각각 액터로 만든 후, 조각 액터를 모두 가지는 부모 액터로 다리를 구성하는 방식이다.
처음에는 조각 액터들을 simulate physics를 false로 만들어두고, 이후에 true로 변경하여 부서지도록 구현을 하게 되었다.
이 방식으로 구현하면, Actor의 리플리케이션을 통해 모든 클라이언트들에게 같은 모습으로 보여줄 수 있기 때문에, 처음한 고민에 있어서도 문제가 없기에 이 방식을 택하게 되었다.

3. 개발

먼저 각 조각 단위의 액터를 만들었다.

이때 주의할 점은 각 메시가 너무 가볍게 날라가는 느낌이 아니라 묵직하게 무너져 내리는 느낌을 내고 싶었다.
- 이 느낌을 내기 위해서 메시의 무게를 무겁게 만드는 방법을 사용하였다.
- 또한 데미지를 가한 방향을 무시하여, 무조건 아래쪽으로만 내려가도록 구현하였다.

AGS_BridgePiece::AGS_BridgePiece()
{
	...
    	MeshComponent->SetSimulatePhysics(false);
	MeshComponent->SetMassOverrideInKg(NAME_None, 100000.0f, true);
}

//데미지 입히기 및 파괴되면 시뮬레이션 시작하는 함수
void AGS_BridgePiece::BrokeBridge(float InDamage)
{
	if (HasAuthority() && !bIsDestroyed)
	{
		CurrentHealth -= InDamage;
		
		if (CurrentHealth <= KINDA_SMALL_NUMBER)
		{
			MeshComponent->SetSimulatePhysics(true);
			MeshComponent->bApplyImpulseOnDamage = false;
			MeshComponent->SetCollisionEnabled(ECollisionEnabled::PhysicsOnly);
			
			...
		}
	}
}

//처음에 StaticMesh를 세팅하는 함수
void AGS_BridgePiece::SetBridgeMesh(UStaticMesh* InMesh, float InValue)
{
	if (MeshComponent && InMesh)
	{
		MeshComponent->SetStaticMesh(InMesh);
		MaxHealth = InValue;
	}
}

이후로 Piece를 포함하는 Bridge 액터를 만들었다.

또한 각 조각마다 체력을 가지고 있어, 일정 데미지 이상 맞은 경우 파괴되는 시스템으로 구현하고 싶었다.
- 이때 가운데 부분에 있어서는 체력을 낮게 설정하여, 쉽게 부서지고 가장자리로 갈수록 체력이 높아서 잘 부서지지 않도록 구현하였다.
- 공중에 가운데 쪽 메시만 떠잇는 모습은 플레이어들에게 이상하게 느껴질 수 있기 때문
Bridge 액터에서는 StaticMesh의 갯수만큼 BridgePiece를 만들어서 ChildActor로 붙여주는 식으로 구성하였다.
- 추가적으로 양 끝에 존재하는 다리 조각은 부서지지 않고 남아있도록 구현하였다.
- 다리가 다 부서져서 사라지는것 보다 "원래 이곳이 다리가 있었던 자리다" 라는 것을 알려주기 위해 부서지지 않게 하였다.

//GS_Bridge.h
//부서지지 않는 액터
UPROPERTY(EditAnywhere)
TObjectPtr<UStaticMeshComponent> NotBrokenPieces1;
...

//GS_Bridge.cpp
void AGS_Bridge::SetUpBridge()
{
	if (HasAuthority())
	{
		HalfBridgeMeshSize = BridgeMeshAssets.Num() / 2;
		
		for (int32 i = 0; i < BridgeMeshAssets.Num(); ++i)
		{
			UStaticMesh* CurrentMesh = BridgeMeshAssets[i];
			if (!CurrentMesh)
			{
				continue;
			}
			
			UChildActorComponent* NewPieceComponent = NewObject<UChildActorComponent>(this);
			if (NewPieceComponent)
			{
				NewPieceComponent->SetChildActorClass(AGS_BridgePiece::StaticClass());
				NewPieceComponent->AttachToComponent(RootComponent,FAttachmentTransformRules::KeepRelativeTransform);
				NewPieceComponent->RegisterComponent();

				AGS_BridgePiece* PieceActor = Cast<AGS_BridgePiece>(NewPieceComponent->GetChildActor());
				if (PieceActor)
				{
                			//가운데 인덱스의 가중치를 크게 만들기
					float weight = 1.f - (abs(i - HalfBridgeMeshSize) / (float)HalfBridgeMeshSize);
					
					FTransform Transform = FTransform::Identity;
					PieceActor->SetActorRelativeTransform(Transform);
					PieceActor->SetBridgeMesh(CurrentMesh, weight * 100.f + 100.f);
				}
			}
		}
	}
}

4. 트러블 슈팅

리플리케이션 관련 문제가 있었다.

GS_BridgePiece의 생성자에서 replicated 설정만 해주었더니 아래와 같이 메시가 보이지 않는 문제가 발생했다.

원인을 찾아보니 액터 자체는 리플리케이트 되지만, 메시 컴포넌트의 변경사항은 클라이언트에게 전송하지 않기 때문이었다.

언리얼 엔진은 성능상의 이슈로 모든 컴포넌트를 복제하지 않기 때문에 필요한 부분에 있어서는 아래와 같이 직접 리플리케이트 세팅을 해주어야 한다.

MeshComponent->SetIsReplicated(true);

참고) GS_Bridge는 리플리케이트 하지 않음

< 패키징 시 오류 발생 >

에디터로 테스트할 때에는 문제가 없었지만, 패키징 시 아래와 같은 에러와 함께 패키징에 실패하였다.
해당 원인 분석 결과 "생성자에서 물리 관련된 속성을 바꾸려고 할 때 생기는 문제" 였다.
CDO라는 것은 에디터에서 속성 패널등을 표시하기 위한 용도로 사용되는 것인데, CDO가 생성될 때는 게임 월드나 GEngine이 아직 로드되지 않은 상황이기 때문에 컴포넌트 자체가 시스템보다 먼저 초기화되면서 생기는 문제였다.

LogPhysics: Error: FBodyInstance::GetSimplePhysicalMaterial : GEngine not initialized! Cannot call this during native CDO construction, wrap with if(!HasAnyFlags(RF_ClassDefaultObject)) or move out of constructor, material parameters will not be correct.

해결 방안으로 생성자에서 진행한 물리세팅 로직을 BeginPlay로 옮겨서 해결하였다.

void AGS_BridgePiece::BeginPlay()
{
	Super::BeginPlay();
	
	...
	MeshComponent->SetSimulatePhysics(false);
	MeshComponent->SetMassOverrideInKg(NAME_None, 100000.0f, true);
}

< 텍스쳐 적용 오류 >

텍스쳐를 적용하기 위해 아래와 같이 SetBridgeMesh 함수에 매개변수를 추가하여 해결하려고하였다.

void AGS_BridgePiece::SetBridgeMesh(UStaticMesh* InMesh, UMaterialInterface* InMaterial, float InValue)
{
	if (MeshComponent && InMesh)
	{
		MeshComponent->SetStaticMesh(InMesh);
        	//텍스쳐 세팅
		MeshComponent->SetMaterial(0, BridgeMaterial);
		MaxHealth = InValue;
	}
}

그러나 이 경우 아래와 같이 텍스쳐 적용이 되지 않는 문제가 있었다.

이유는 SetMaterial 함수가 리플리케이티드 되지 않기 때문이었다.
이것을 해결하기 위해서 Material 자체를 OnRep함수와 연동하여 클라이언트 쪽에서 SetMaterail 함수를 호출하도록 구현하였다.

//헤더
UFUNCTION()
void OnRep_BridgeMaterial();

UPROPERTY(ReplicatedUsing=OnRep_BridgeMaterial)
UMaterialInterface* BridgeMaterial;

//cpp
void AGS_BridgePiece::SetBridgeMesh(UStaticMesh* InMesh, UMaterialInterface* InMaterial, float InValue)
{
	if (MeshComponent && InMesh)
	{
		MeshComponent->SetStaticMesh(InMesh);

		if (InMaterial)
		{
			BridgeMaterial = InMaterial;
		}
		MaxHealth = InValue;
	}
}

void AGS_BridgePiece::OnRep_BridgeMaterial()
{
	if (MeshComponent && BridgeMaterial)
	{
		MeshComponent->SetMaterial(0, BridgeMaterial);
	}
}

해결된 모습

5. 결과 및 추후 개발할 것

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

현재까지 결정된 내용으로는 일정 시간 시뮬레이션 후, 사라지는 것으로 기획이 결정되었다.
사라질때 디졸브 효과로 사라지게 하는 것을 추가할 예정이며,
사라지는 것으로 기획이 픽스된다면, 카오스를 통해 갈비뼈와 같이 약한 부분을 부수는 시스템을 추가하여 좀 더 실감나는 파괴 시뮬레이션을 구현해 볼 예정이다.

UnrealEngine - HitStop

gbleem — Tue, 17 Jun 2025 15:27:09 +0900

전투 게임에 있어서 가장 중요한 부분중에 하나가 타격감이다.

여러가지 정보를 찾다가 아래 영상을 통해 Hit Stop이라는 것을 접하게 되었고 게임에 적용해 보게 되었다.

https://youtu.be/IL9j4NchTvA?si=MM6F7kJEw7RysZRI&t=1951

1. 기능 구현

가장 간단한 방식으로는 해당 시점에 시간을 느리게 만들어주는 방식이 존재한다.

코드를 보면

SetGlobalTimeDilation을 통해 World의 시간을 지연시켜서 느려지도록 하는 방식이다.
단순히 싱글플레이 게임에 있어서는 아래와 같은 방식을 사용해도 문제가 없을것이지만, 현재 게임은 멀티플레이 게임이기 때문에 멀티캐스트를 통해서 시간 지연하는 함수를 사용하기 때문에 월드에 존재하는 모든 플레이어들의 시간이 느려지는 문제가 있다.

void AGS_Guardian::MulticastRPCApplyHitStop_Implementation()
{
	if (GetWorld() && GetWorld()->GetNetMode() == NM_DedicatedServer)
	{
		return;	
	}

	UGameplayStatics::SetGlobalTimeDilation(GetWorld(), HitStopTimeDilation);
	GetWorld()->GetTimerManager().SetTimer(HitStopTimerHandle, this, &AGS_Guardian::EndHitStop, HitStopDurtaion*HitStopTimeDilation, false);
}

void AGS_Guardian::EndHitStop()
{
	UGameplayStatics::SetGlobalTimeDilation(GetWorld(), 1.f);
}

2. 트러블슈팅

위에서 언급한 문제를 해결하기 위해 CustomTimeDelation을 사용하였다.

https://dev.epicgames.com/documentation/en-us/unreal-engine/API/Runtime/Engine/GameFramework/AActor/CustomTimeDilation

해당 기능은 각 액터가 가진 기능으로
액터 각각의 시간을 지연시키는 기능이기 때문에 멀티플레이에 있어서 해당 기능을 사용하는 것이 더 좋은 방식이다.

새롭게 구현된 코드는 아래와 같다.

데미지를 입은 캐릭터를 매개변수로 넣어준 후 멀티캐스트를 통해 HitStop을 적용해준다.
이후에 "타이머 델리게이트"를 통해서 EndHitStop 함수에 데미지를 입은 캐릭터를 매개변수로 넣어주었다.
추가적으로 CameraShake 기능을 추가하였다.

void AGS_Guardian::ApplyDamageToDetectedPlayer(const TSet<AGS_Character*>& DamagedCharacters, float PlusDamge)
{
	for (auto const& DamagedCharacter : DamagedCharacters)
	{
    	      ...
	      MulticastRPCApplyHitStop(DamagedCharacter);			
        
	}
}
void AGS_Guardian::MulticastRPCApplyHitStop_Implementation(AGS_Character* InDamagedCharacter)
{
	if (HasAuthority())
	{
		if (CameraShakeComponent)
		{
			CameraShakeComponent->PlayCameraShake(HitStopShakeInfo);
		}
	}
	if (!HasAuthority())
	{
		CustomTimeDilation = 0.1f;
		InDamagedCharacter->CustomTimeDilation = 0.1f;

		FTimerDelegate HitStopTimerDelegate;
		FTimerHandle HitStopTimerHandle;
        
		HitStopTimerDelegate.BindUFunction(this, FName("EndHitStop"), InDamagedCharacter);
		GetWorld()->GetTimerManager().SetTimer(HitStopTimerHandle, HitStopTimerDelegate, HitStopDurtaion, false);
	}
}

void AGS_Guardian::MulticastRPCEndHitStop_Implementation(AGS_Character* InDamagedCharacter)
{
	if (!HasAuthority())
	{
		CustomTimeDilation = 1.f;
		InDamagedCharacter->CustomTimeDilation = 1.f;
	}
}

결과 영상

아래 두 화면 (공격자와 피격자) 의 캐릭터만 화면 흔들림과 시간 지연이 발생한다
오른쪽 위 화면의 캐릭터는 시간지연 발생 x

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

UE5 Issues : 데디케이트 서버 UI에 관해

gbleem — Thu, 12 Jun 2025 12:31:01 +0900

멀티플레이 게임에서 UI를 개발함에 있어서 고려할 만한 점이 있다.

Owner설정

UI의 Owner
UI에 띄울 정보를 가질 Owner

보이는 곳

Owner에게만 보여줄 것인가
다른 유저들에게도 보여줄 것인가

위젯에서 표시할 값이 어디에서 변하는가

서버에서 변경
클라이언트에서 변경

1. Owner 설정과 보여지는 곳

예를 들어, 우리가 자신의 체력 바를 만든다고 했을 때를 생각해 보자

UI의 Owner는 나 자신이고, 띄울 정보의 Owner도 나 자신이다.
보여지는 곳은 나 자신이 될 것이다.
이 경우는 크게 생각할 문제가 없다.

그러나 우리가 다른 플레이어의 체력 바를 또한 띄우고 싶다면

UI의 Owner는 나 자신이지만, 띄울 정보는 다른 플레이어의 정보이다.
보여지는 곳은 여전히 나 자신이 된다.
이 경우 해당 Widget을 초기화 함에 있어서 다른 플레이어의 정보를 통해서 초기화 해주어야 한다.

아래의 코드를 보면

위젯 이름 설명
- HP_BoardWidget은 우리 팀원의 체력을 붙여서 띄워줄 VertexBox를 가지고 있는 클래스이다.
- HP_Widget의 경우는 각 팀원들의 체력을 나타내는 클래스이다.
코드 설명
- 각각의 HP_Widget의 정보의 Owner는 나를 제외한 다른 플레이어이다.
- 그렇게 때문에 GameState의 PlayerArray를 통해 모든 플레이어의 정보 순환하면서 Owner를 각 플레이어로 지정해주고 부모 Widget인 HP_BoardWidget에 붙여준다.

void UGS_HPBoardWidget::InitBoardWidget()
{
	if (!IsValid(HPWidgetClass) || !IsValid(HPWidgetList))
	{
		return;
	}
	
	HPWidgetList->ClearChildren();

	AGameStateBase* GS = UGameplayStatics::GetGameState(this);
	if (IsValid(GS))
	{
		TArray<APlayerState*> PSA = GS->PlayerArray; 
		for (APlayerState* PS : PSA)
		{
			AGS_PlayerState* GSPS = Cast<AGS_PlayerState>(PS);
			if (IsValid(GSPS))
			{
				UGS_HPWidget* HPWidget = CreateWidget<UGS_HPWidget>(this, HPWidgetClass);
				if (IsValid(HPWidget))
				{
					AGS_Character* Character = Cast<AGS_Character>(GSPS->GetPawn());

					//자기 자신 제외
					if (IsValid(Character) && Character != OwningCharacter)
					{
						//가디언 제외
						if (GSPS->CurrentPlayerRole == EPlayerRole::PR_Guardian)
						{
							continue;
						}
						
						HPWidget->SetOwningActor(Character);
						HPWidget->InitializeHPWidget(Character->GetStatComp());
						HPWidgetList->AddChildToVerticalBox(HPWidget);
					}
				}
			}
		}
	}	
}

부모 Widget인 HP_BoardWidget의 Owner는 나 자신이기 때문에 아래와 같이 생성자에서 OwningActor를 GetOwningPlayer()를 통해 지정해준다.

void UGS_HPBoardWidget::NativeConstruct()
{
	Super::NativeConstruct();

	if (IsValid(GetOwningPlayer()->GetPawn()))
	{
		OwningCharacter = Cast<AGS_Character>(GetOwningPlayer()->GetPawn());
	}
    ...
}

2. 어디에서 값이 변경되는가

두가지 경우가 있을 수 있다.

값이 클라이언트에서 변경
혹은 서버에서 변경

값이 클라이언트에서 변하고, 위젯 Owner만 값을 보는 경우는 크게 생각할 것이 없다.

그러나, 값이 서버에서 변경되었을 때 모든 클라이언트가 해당 값을 보고 싶은 경우가 많다.

보스 몬스터의 체력과 피버 게이지
다른 플레이어의 체력 등...

현재 진행하는 프로젝트를 예를 들면, 보스 몬스터의 체력과 피버 게이지를 생각해 볼 수 있다.

빨간색 화살표가 체력, 파란색 화살표가 피버 게이지

2 - 1. 보스 몬스터의 체력

플레이어의 체력은 변수 자체가 replicated된 상태이다.
- 주의할 점은 체력의 변경은 주요 로직이므로 "서버"에서 진행된다.
- 그렇기 때문에, 변경된 순간 클라이언트 쪽에서도 값을 업데이트 해줘야한다.
- 이 경우 ReplicatedUsing 키워드를 통해서 클라이언트로 값을 알려주었다.
또한 해당 체력을 가지고 있는 Stat 컴포넌트가 변수는 delegate를 통해 연동되어서 값이 바뀔 때마다 위젯의 함수를 호출하여 체력 게이지의 값을 변경해준다.
로직
- StatComp와 HPWidget을 Delegate 바인딩 하기
- StatComp에 존재하는 CurrentHealth 변수가 SetCurrentHealth 를 통해 변경되면 BroadCast를 통해 위젯의 업데이트 함수가 call된다.
- 이때 OnRep 함수를 통해 클라이언트에서도 BroadCast하게 되면서 모든 클라이언트 위젯이 업데이트 된다.
이때 주의할 점은 OnRep을 통해서 클라이언트에 변경된 값을 알려주지 않는다면, 위젯이 업데이트되지 않는다

//GS_StatComp.h
DECLARE_MULTICAST_DELEGATE_OneParam(FOnCurrentHPChangedDelegate, UGS_StatComp*);

UPROPERTY(ReplicatedUsing = OnRep_CurrentHealth)
float CurrentHealth;

//GS_StatComp.cpp
void UGS_StatComp::OnRep_CurrentHealth()
{
	OnCurrentHPChanged.Broadcast(this);
}

void UGS_StatComp::SetCurrentHealth(float InHealth, bool bIsHealing)
{
	...
        CurrentHealth = InHealth;
	OnCurrentHPChanged.Broadcast(this);
    
    ...
}

//GS_Character.cpp
void AGS_Character::SetHPBarWidget(UGS_HPWidget* InHPBarWidget)
{
	UGS_HPWidget* HPBarWidget = Cast<UGS_HPWidget>(InHPBarWidget);
	if (IsValid(HPBarWidget))
	{
		HPBarWidget->InitializeHPWidget(GetStatComp());
		StatComp->OnCurrentHPChanged.AddUObject(HPBarWidget, &UGS_HPWidget::OnCurrentHPBarChanged);
	}
}

//GS_HPWidget.cpp
void UGS_HPWidget::NativeConstruct()
{
	Super::NativeConstruct();

	if (!IsValid(OwningCharacter))
	{
		OwningCharacter = Cast<AGS_Character>(GetOwningPlayer()->GetPawn());
	}
	
	if (IsValid(OwningCharacter))
	{
		OwningCharacter->SetHPBarWidget(this);
	}
}
void UGS_HPWidget::OnCurrentHPBarChanged(UGS_StatComp* InStatComp)
{
 	HPBarWidget->SetPercent(InStatComp->GetCurrentHealth()/InStatComp->GetMaxHealth());
}

2 - 2. 보스 몬스터의 피버 게이지

피버 게이지의 경우 변수를 리플리케이트하지 않았다.
그렇기 때문에, 이 값들을 다른 클라이언트에게 모두 알려주기 위해서 Multicast를 사용하였다.
체력과 거의 유사한 구조로 구성되었지만, 값을 변경해주는 함수를 Multicast로 만든 것이 차이점이다.

//GS_Drakhar.h
DECLARE_MULTICAST_DELEGATE_OneParam(FOnCurrentFeverGageChangedDelegate, float);

float CurrentFeverGage;

//GS_Drakhar.cpp
void AGS_Drakhar::SetFeverGageWidget(UGS_DrakharFeverGauge* InDrakharFeverGageWidget)
{
	UGS_DrakharFeverGauge* DrakharFeverGaugeWidget = Cast<UGS_DrakharFeverGauge>(InDrakharFeverGageWidget);
	if (IsValid(DrakharFeverGaugeWidget))
	{
		//client
		DrakharFeverGaugeWidget->InitializeGage(GetCurrentFeverGage());
		OnCurrentFeverGageChanged.AddUObject(DrakharFeverGaugeWidget, &UGS_DrakharFeverGauge::OnCurrentFeverGageChanged);
	}
}

void AGS_Drakhar::MulticastRPCSetFeverGauge_Implementation(float InValue)
{	
	CurrentFeverGage += InValue;
	...
	
	OnCurrentFeverGageChanged.Broadcast(CurrentFeverGage);
}

void AGS_Guardian::ApplyDamageToDetectedPlayer(const TSet<AGS_Character*>& DamagedCharacters, float PlusDamge)
{
	for (auto const& DamagedCharacter : DamagedCharacters)
	{
		...
        
			AGS_Drakhar* Drakhar = Cast<AGS_Drakhar>(this);
			if (!Drakhar->GetIsFeverMode())
			{
				Drakhar->MulticastRPCSetFeverGauge(10.f);
			}
		}
	}
}

2 - 3. 어떤 방식이 더 좋은가?

멀티캐스트 하는 방식에는 가장 큰 문제점이 존재한다.
만약 다른 플레이어가 게임 도중에 들어온 경우, 피버 게이지의 값이 동기화 되지 않는 문제점이 있다.
아래 사진과 같은 문제

변수를 리플리케이트 되도록 수정한 버전

체력과 마찬가지로 OnRep을 통해 클라이언트에게 알려주도록 구현

//Drakhar.h
UPROPERTY(ReplicatedUsing=OnRep_FeverGauge)
float CurrentFeverGauge;

UFUNCTION()
void OnRep_FeverGauge();

//Drakhar.cpp
void AGS_Drakhar::OnRep_FeverGauge()
{
	OnCurrentFeverGageChanged.Broadcast(CurrentFeverGauge);
}

void AGS_Drakhar::GetLifetimeReplicatedProps(TArray<class FLifetimeProperty>& OutLifetimeProps) const
{
	Super::GetLifetimeReplicatedProps(OutLifetimeProps);

	...
	DOREPLIFETIME(ThisClass, CurrentFeverGauge);
}

결과 모습

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

Unreal Engine - 데디케이티드 서버 11 (콤보 공격 최적화)

gbleem — Mon, 2 Jun 2025 02:23:44 +0900

1. 언리얼 인사이트

언리얼 프로파일링 툴인 Unreal Insights를 통해서 최적화 테스트를 해 볼 생각이다.

1 - 1. 설정

언리얼 엔진을 다운로드한 경로로 가서 아래와 같이 UnrealInsights.exe 파일을 찾는다.
- 일반적으로 아래와 같은 경로로 저장된다.
- C:\Program Files\Epic Games\UE_5.5\Engine\Binaries\Win64

쉽게 사용하기 위해 환경변수에 등록을 한다

이후 프로파일링을 하고자 하는 프로젝트가 있는 폴더로 들어가서 bat 파일을 만들어준다

내용은 아래와 같이 환경변수를 사용하여 만들면 된다.

UnrealEditor.exe %cd%\SCC_DedicatedX.uproject -NetTrace=1 -Trace=Net

1 - 2. 사용

bat 파일을 더블클릭하면, 에디터를 실행시킬 수 있다.

실행 후 "언리얼 인사이트"를 실행
아래 사진 처럼 Connection을 들어간 후 Connect를 눌러서 연결한다.

Connect가 되면 아래와 같이 LIVE 표시가 뜬다. LIVE 표시가 뜬 것을 선택 후 Open Trace를 눌러서 실행시킨다.

아래와 같이 프로파일링 화면이 뜨는 것을 볼 수 있다.

2. 서버 과부화

Unreal Engine - 데디케이티드 서버 10 (콤보 공격)

gbleem — Fri, 30 May 2025 02:40:23 +0900

1. 플레이어 쪽 함수 세팅

새로운 인풋 액션인 IA_ComboAttack을 추가한 후 Input Binding 진행

Section을 사용해야 하기 때문에, SectionName에 사용할 변수를 추가

//헤더
FName ComboAttackSectionName;
FName DefaultComboAttackSectionName;

//cpp
void ADXPlayerCharacter::HandleComboAttackInput(const FInputActionValue& InValue)
{
	if (!HasAuthority() && IsLocallyControlled())
	{
		PlayAnimMontage(ComboAttackMontage, 1.f, ComboAttackSectionName);
		//ServerRPCComboAttack();
	}
}

2. 애니메이션 노티파이 스테이트

애니메이션이 진행되는 동안 애니메이션 노티파이 스테이트를 통해 로직 수행

다음 section을 나타내는 변수 존재
해당 변수를 통해 다음 섹션으로 넘어갈 수 있도록 Player의 함수와 연동하기

//헤더
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "Animation")
FName SectionName;

//cpp
void UDXANSMeleeCombo::NotifyBegin(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation, float TotalDuration)
{
	Super::NotifyBegin(MeshComp, Animation, TotalDuration);

	ADXPlayerCharacter* PlayerCharacter = Cast<ADXPlayerCharacter>(MeshComp->GetOwner());
	if (IsValid(PlayerCharacter))
	{
		PlayerCharacter->SetNextComboAttack(SectionName);
	}
}

void UDXANSMeleeCombo::NotifyEnd(USkeletalMeshComponent* MeshComp, UAnimSequenceBase* Animation)
{
	Super::NotifyEnd(MeshComp, Animation);
	
	ADXPlayerCharacter* PlayerCharacter = Cast<ADXPlayerCharacter>(MeshComp->GetOwner());
	if (IsValid(PlayerCharacter))
	{
		PlayerCharacter->ResetComboAttack();
	}
}

void ADXPlayerCharacter::SetNextComboAttack(FName InSectionName)
{
	ComboAttackSectionName = InSectionName;
}

void ADXPlayerCharacter::ResetComboAttack()
{
	ComboAttackSectionName = DefaultComboAttackSectionName;
}

3. 애니메이션 몽타주

애니메이션 몽타주에서 Section을 이용하여 콤보 공격을 구현할 것

먼저 애니메이션 몽타주를 만든 후 아래와 같이 사용하고자 하는 애니메이션을 넣기
각 애니메이션이 시작하는 곳에 section을 만든 다음 사용하고자 하는 이름으로 변경
전에 만들어둔 "애님 노티파이 스테이트"를 추가 (ANS는 다음 섹션으로 넘어가도 되는 부분부터 시작하도록)

각 애니메이션 노티파이 스테이트에 있어서 C++로 만들어 둔 변수에 아래와 같이 다음으로 재생할 section의 이름을 넣어준다.

아래 사진은 Combo1 섹션에 존재하는 ANS의 변수 세팅 모습

다음으로 각 section이 연결된 링크를 제거하여 모두 따로 분리해 준다.

분리하하면 아래와 같은 모습이 된다.

모두 분리된 섹션

지금까지 실행 결과

아직 서버 관련 로직을 넣지 않았기 때문에 아래와 같이 자신의 화면에서만 보인다
combo 공격은 잘 이루어지는 모습

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

4. 트러블 슈팅 (연속 공격 방지)

현재 문제는 연속된 input (연속 클릭) 시 첫 몽타주가 계속해서 플레이되는 문제가 존재한다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

문제 해결을 위해서 현재 몽타주가 재생중인지에 대한 변수를 추가해 줄 것이다.

또한 NotifyBegin 함수와 바인딩을 통해 해당 노티파이에서 실행할 함수를 만들어 주었다.

bCanCombo 변수를 추가
input 바인딩 된 함수에서 실행하면서 bCanCombo를 false로 변경
OnMontageNotifyBegin이라는 함수를 OnPlayMontageNotifyBegin에 바인딩
- 위 애님 몽타주 사진에서 본 것처럼 "None" 몽타주 노티파이에서 바인딩 된 함수를 실행
- 바인딩 된 함수에서는 다시 bCanCombo를 true로 만들어주기

void ADXPlayerCharacter::BeginPlay()
{
	Super::BeginPlay();

    ...

	UDXAnimInstanceBase* Anim = Cast<UDXAnimInstanceBase>(GetMesh()->GetAnimInstance());
	if (IsValid(Anim))
	{
		Anim->OnPlayMontageNotifyBegin.AddDynamic(this, &ThisClass::OnMontageNotifyBegin);
	}
}

void ADXPlayerCharacter::HandleComboAttackInput(const FInputActionValue& InValue)
{
	if (!HasAuthority() && IsLocallyControlled())
	{
		if (bCanCombo)
		{
			PlayAnimMontage(ComboAttackMontage, 1.f, ComboAttackSectionName);
			bCanCombo = false;
		}
	}
}

void ADXPlayerCharacter::OnMontageNotifyBegin(FName NotifyName, const FBranchingPointNotifyPayload& PayLoad)
{
	if (NotifyName == "None")
	{
		bCanCombo = true;
	}
}

결과 모습

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

5. 서버 로직 추가 (몽타주 재생)

우선 서버에서 해당 애니메이션을 볼 수 있도록 처리를 할 것이다.

콤보 공격 몽타주를 출력해주는 코드를 함수로 따로 빼주고

void ADXPlayerCharacter::PlayComboAttackMontage()
{
	PlayAnimMontage(ComboAttackMontage, 1.f, ComboAttackSectionName);
}

아래와 같이 인풋 바인딩 시 실행되는 함수를 수정해 주었다.

몽타주 함수 실행
ServerRPC 함수 추가

void ADXPlayerCharacter::HandleComboAttackInput(const FInputActionValue& InValue)
{
	if (!HasAuthority() && IsLocallyControlled())
	{
		if (bCanCombo)
		{
			PlayComboAttackMontage();
			bCanCombo = false;
			ServerRPCComboAttack();
		}
	}
}

ServerRPC 함수에서는 아래와 같이 서버와 자기 자신을 제외한 플레이어에게 Multicast 함수를 통해 몽타주를 재생하도록 한다.

//헤더
UFUNCTION(Server, Reliable)
void ServerRPCComboAttack();
    
UFUNCTION(NetMulticast, Unreliable)
void MulticastRPCComboAttack();
    
//cpp
void ADXPlayerCharacter::ServerRPCComboAttack_Implementation()
{
	MulticastRPCComboAttack();
}

void ADXPlayerCharacter::MulticastRPCComboAttack_Implementation()
{
	//except server and owner player
	if (!HasAuthority() && !IsLocallyControlled())
	{
		PlayComboAttackMontage();
	}
}

결과

몽타주가 다른 클라이언트에게도 보이는 것을 확인할 수 있다.

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

6. 서버 로직 추가 (데미지 처리)

생각할 점) 데미지 처리 로직은 중요한 로직이기 때문에 서버에서 처리를 해야한다.

데미지를 입히는 함수를 아래와 같이 서버에서 돌아가는 로직으로 아래와 같이 작성해 볼 수 있다.

void ADXPlayerCharacter::CheckMeleeAttackHit()
{
	//server
	if (HasAuthority())
	{
		TArray<FHitResult> OutHitResults;
		TSet<ACharacter*> DamagedCharacters;
		FCollisionQueryParams Params(NAME_None, false, this);

		const float MeleeAttackRange = 50.f;
		const float MeleeAttackRadius = 50.f;
		const float MeleeAttackDamage = 10.f;

		const FVector Forward = GetActorForwardVector();
		const FVector Start = GetActorLocation() + Forward * GetCapsuleComponent()->GetScaledCapsuleRadius();
		const FVector End = Start + GetActorForwardVector() * MeleeAttackRange;

		bool bIsHitDetected = GetWorld()->SweepMultiByChannel(OutHitResults, Start, End, FQuat::Identity, ECC_Camera, FCollisionShape::MakeSphere(MeleeAttackRadius), Params);
		if (bIsHitDetected)
		{
			for (auto const& OutHitResult : OutHitResults)
			{
				ACharacter* DamagedCharacter = Cast<ACharacter>(OutHitResult.GetActor());
				if (IsValid(DamagedCharacter))
				{
					DamagedCharacters.Add(DamagedCharacter);
				}
			}

			FDamageEvent DamageEvent;
			for (auto const& DamagedCharacter : DamagedCharacters)
			{				
				DamagedCharacter->TakeDamage(MeleeAttackDamage, DamageEvent, GetController(), this);
			}
		}
		FColor DrawColor = bIsHitDetected ? FColor::Green : FColor::Red;
		MulticastDrawDebugMeleeAttack(DrawColor, Start, End, Forward);
	}
}

참고) TakeDamage 함수는 기존의 TakeDamage 함수를 override한 함수이다.

virtual float TakeDamage(float DamageAmount, struct FDamageEvent const& DamageEvent, class AController* EventInstigator, AActor* DamageCauser) override;

위에서 만든 로직은 애니메이션 몽타주에서 재생할 수 있도록 애님 인스턴스 클래스에 Notify 함수를 만들어서 실행시켰다.

//헤더
UFUNCTION()
void AnimNotify_CheckMeleeAttackHit();

//cpp
void UDXAnimInstanceBase::AnimNotify_CheckMeleeAttackHit()
{
	ADXPlayerCharacter* OwnerPlayerCharacter = Cast<ADXPlayerCharacter>(OwnerCharacter);
	if (IsValid(OwnerPlayerCharacter))
	{
		OwnerPlayerCharacter->CheckMeleeAttackHit();
	}
}

새로 만든 노티파이라면,
- 노티파이 칸 우클릭 -> 노티파이 추가 -> 새 노티파이 -> 이름 추가(위에서 만든 함수에서 언더바 이후의 이름 사용)
이전에 만들었던 노티파이라면
- 아래와 같이 선택

추가) 몽타주 틱 타입을 Branching Point로 수정

완성된 모습

7. 트러블 슈팅 (데미지 처리)

그러나 위의 설정만 진행한 다음 실행하면, 공격 처리가 안된다. (아래 영상 참고)

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.

원인을 찾아보기 위해 현재 로직을 살펴보면

로컬 플레이어만 인풋 바인딩 함수 실행
- 몽타주 실행
- 서버 RPC 실행
로컬 플레이어의 몽타주 실행의 경우
- 서버에서 실행되는 로직이 없으므로 CheckMeleeAttackHit 함수가 실행될 수 없다.
서버 RPC를 실행한 경우
- 멀티캐스트를 하지만, 멀티캐스트 함수에서 !HasAuthority() 일때 실행되기 때문에
- 마찬가지로 서버의 로직이 없다.

해결하기 위해서는

CheckMeleeAttackHit 함수를 ServerRPC 함수로 만들거나
멀티캐스트를 서버에서도 진행하게 해주는 방법이 있다.

이번에는 멀티캐스트를 서버에서 진행할 수 있도록 하는 방법을 사용해서 해결해 볼 것이다.

아래와 같이 멀티캐스트 함수를 수정

void ADXPlayerCharacter::MulticastRPCComboAttack_Implementation()
{
	if (!IsLocallyControlled())
	{
		PlayComboAttackMontage();
	}
}

결과 모습

동영상 서비스가 종료되어 해당 콘텐츠를 재생할 수 없습니다.