따알깍PROMPT DICT 앱으로 열기

장르 문법 · 액션 · 어드벤처 · 액션 RPG · 핵앤슬래시

핵앤슬래시 기술 구현 Hack-and-slash implementation

몬스터 200마리가 몰려도 프레임이 버티도록, 경로 · 공간 질의 · 데이터 배치 · 서버 판정을 실제 숫자로 정하는 핵앤슬래시 구현 설계 모음이다.

카드 40개 · 카드마다 설명과 바로 복사해 쓸 수 있는 프롬프트 전문 · 앱에서 라이브 데모로 보기

카드 목록 40개
  1. 클릭 이동 재경로 주기 (누르는 동안 10 f + 0.5 m 변화)
  2. 군중 속 커서 타겟 (몸통 캡슐 + 놓기 r 9 · 12 f 유지)
  3. 공간 해시 칸 크기 (질의 반지름 3 m면 칸도 3 m)
  4. 범위 질의 비용 (전원 타격 · 반응만 최근접 16명)
  5. 군중 분리 2교대 (해시 1 m · 절반씩 번갈아 · 힘 ×2)
  6. 추적 방향 표 vs 개별 A* (목표가 1명이면 BFS 한 번)
  7. 거리별 AI 주기 (14 m 안 60 Hz · 경고 중이면 승격)
  8. 타격 시점은 교차로 판정 (prev < 16 ≤ k · 어떤 공속에서도 정확히 1회)
  9. 최악 프레임 예산표 (시스템 8개 합 14.2 ms)
  10. 상태 이상 평평한 배열 (16 B · 끝과 교체해 삭제)
  11. 접사는 롤 값으로 저장 (id · 티어 · 롤 = 4 B)
  12. 드롭은 서버가 굴림 (터지는 동작 12 f로 왕복 지연 가림)
  13. 바닥 이름표 자리 고정 (새 항목만 빈 자리 찾기)
  14. 소켓으로 잇는 던전 (조각 48 m = 타일 2장 · 시연 14조각 · 미리 구운 내비)
  15. 벽 조각별 가림 판정 (x+y 키 · 겹친 조각만 25 %)
  16. 스킬을 데이터로 (노드 6개 → 연산표 48 B)
  17. 발동 연쇄 방지 (세대 ≤ 3 · 프레임당 8개)
  18. 적 동기화 대역폭 (행동 변경만 전송 · 예산 20 KB/s)
  19. 아이템 이동은 한 트랜잭션 (uid 유일 · 복제 0 · 유실 0)
  20. 처치 스파이크 분산 (무거운 처리 프레임당 6마리)
  21. 깨어 있는 무리만 갱신 (24 m에 깨움 · 34 m에 재움)
  22. 투사체 풀과 몬스터 해시 (자기 칸만 조회 · 0.30 m/f면 스윕 없음)
  23. 시체 고리 버퍼 (몸이 화면에 남는 5.6초를 덮는 64칸)
  24. 무리 활성화는 화면 밖 18 m부터 (프레임당 2마리)
  25. 사수의 발사 판정은 화살 경로와 같은 칸 순회로 (아니면 14 %가 벽 너머로 샌다)
  26. 벽 앞 넉백은 8 f 축 분리 (벽 박힘 0 · X 먼저 Y 나중)
  27. 광역 적중 보고는 비트열로 (대상 7명부터 25 B)
  28. 피해 계산 둘로 나누기 (공격자 쪽 시전당 1번 · 대상 쪽만 반복)
  29. 안개를 비트로 저장 (256 × 256 = 8 KB · 줄 단위 OR)
  30. 바닥 장판 풀 나누기 (내 그을음 24칸 + 위험 원 8칸)
  31. 루트 필터는 드롭 순간 한 번 (종류별 표 · 결과 1 B 저장)
  32. 이동 복제는 목적지 8 B만 (위치 스트림의 13 %)
  33. 바닥 청크 16 m · ±1칸 (구멍 0 · 읽기 18 f보다 여유 24 f)
  34. 골드 더미 합치기 (착지 때 1 m 안이면 합산 · 자석 4 m)
  35. 균열 진행도 표시는 뒤로 가지 않는다 (서버 값 + 대기분의 최댓값)
  36. 큰 체력은 정수로 (float32면 12 · 15가 사라지고 20이 32로)
  37. 주인공은 몬스터에 막히지 않는다 (몬스터가 프레임당 0.15 m 비킴)
  38. 장판 질의는 12 f 주기로 위상을 나눈다 (번호로 분산 · 최고 22 µs)
  39. 서버 쿨다운 검사 허용 6 f + 빚 (거절 0 · 일찍 보내도 이득 없음)
  40. 끼인 몬스터 구출 (120 f에 0.3 m 미만 · 화면 밖은 워프)

클릭 이동 재경로 주기 (누르는 동안 10 f + 0.5 m 변화)

Hold-to-move re-path cadence: 10-frame timer gated by 0.5 m cursor change

  • Unity
  • C#
  • A*

마우스를 누른 채 이동할 때 경로를 언제 다시 구할지는 비용보다 움직임의 품질 문제다. 매 프레임 구하면 같은 거리의 경로끼리 뒤집혀 방향이 자주 꺾이고, 30 f면 커서를 1.9 m나 늦게 따라간다.

프롬프트

15×9칸 격자에서 커서를 따라가는 주인공(5 m/s)의 A* 재탐색을 매 프레임 · 10 f + 커서 0.5 m 이상 변화 · 30 f 세 가지로 나란히 돌려줘. 초당 계산 60/6/2회, 전개 노드, 방향 꺾임, 목표 지연(0.56/0.75/1.86 m)을 HUD에 표시하고, 아래 타임라인에 재탐색 시점을 눈금으로 그려줘.

라이브 데모 열기 — 클릭 이동 재경로 주기 (누르는 동안 10 f + 0.5 m 변화)

군중 속 커서 타겟 (몸통 캡슐 + 놓기 r 9 · 12 f 유지)

Cursor picking in a crowd: body capsule test with sticky target and 12-frame release

  • Unity
  • C#
  • Raycast

몬스터가 겹치는 화면에서 커서에 가장 가까운 중심점을 고르면 대상이 프레임마다 바뀌어 엉뚱한 놈을 때린다. 발에서 머리까지의 캡슐로 판정하고 한번 잡은 대상은 더 넓은 반경과 12 f 동안 유지하면 교체가 사라진다.

프롬프트

11마리가 교차하는 아이소 화면에서 커서 대상 선택을 두 방식으로 비교해줘. A는 몸 중심 최근접 16 px, B는 발-머리 캡슐 거리 6 px로 잡고 9 px 안이면 유지, 벗어나도 12 f 동안 놓지 않게 해. 6초 동안 대상 교체 13회 vs 0회, 클릭 8번 중 의도한 대상 명중 5 vs 8을 표시하고 프레임별 대상을 색 띠로 그려줘.

라이브 데모 열기 — 군중 속 커서 타겟 (몸통 캡슐 + 놓기 r 9 · 12 f 유지)

공간 해시 칸 크기 (질의 반지름 3 m면 칸도 3 m)

Spatial hash cell size for 200 monsters: matching the 3 m query radius

  • Unity
  • C++
  • DOTS

칸이 너무 작으면 빈 칸을 도는 비용이, 너무 크면 거리 계산 후보가 늘어난다. 표준 범위 스킬 반지름 3 m를 기준으로 칸을 맞추면 200마리 질의 1회의 일이 전수 검사의 5분의 1 아래로 떨어진다.

프롬프트

40×24 m에 무리 지은 몬스터 200마리를 두고 반지름 3 m 질의를 칸 크기 1 · 3 · 10 m로 번갈아 보여줘. 질의 칸을 강조하고 후보는 노랑, 실제 적중은 빨강으로 칠해. 일의 양은 칸 조회 × 2 + 후보 수로 계산해 질의 120회 평균 112 · 39 · 59를 표로 비교해줘.

라이브 데모 열기 — 공간 해시 칸 크기 (질의 반지름 3 m면 칸도 3 m)

범위 질의 비용 (전원 타격 · 반응만 최근접 16명)

Area query cost: damage all targets, cap hit reactions to the nearest 16

  • Unity
  • C#
  • ECS

핵앤슬래시의 쾌감은 무리 전체가 한 번에 죽는 데 있으므로 피해 대상은 자르지 않는다. 비싼 건 경직 · 숫자 · 불꽃 같은 반응이라, 이것만 가까운 16명으로 제한해 대상이 64마리여도 광역 1회를 0.5 ms 안에 끝낸다.

프롬프트

아이소 바닥에 반지름 3 m 광역기를 12 · 32 · 64마리에 차례로 터뜨려줘. 1마리당 피해 0.4 µs, 반응 22 µs, 적중 발동 6 µs로 두고, 전원 처리 341 · 909 · 1,818 µs와 가까운 16명만 반응 341 · 461 · 474 µs를 예산선 500 µs와 비교하는 막대를 그려줘. 가까운 16명은 nth_element로 고르고 흰색으로 번쩍이게 해줘.

라이브 데모 열기 — 범위 질의 비용 (전원 타격 · 반응만 최근접 16명)

군중 분리 2교대 (해시 1 m · 절반씩 번갈아 · 힘 ×2)

Crowd separation at scale: neighbour hash with alternating half updates

  • Unity
  • C#
  • Jobs

200마리의 전수 쌍 검사는 프레임당 19,900번이다. 1 m 해시로 이웃만 보고, 짝수 · 홀수 번호를 번갈아 갱신하면서 밀어내는 힘을 2배로 주면 겉모습은 그대로 두고 검사를 다시 절반으로 줄인다.

프롬프트

몬스터 200마리(몸 반지름 0.34 m, 3.4 m/s)가 원을 그리며 달리는 주인공을 둘러싸게 하고 분리 조향을 두 벌로 돌려줘. A는 매 프레임 전원, B는 번호 짝홀로 절반씩 갱신하고 힘을 2배로 해. 전수 19,900쌍 · 해시 전원 · 해시 절반의 실제 쌍 검사 수를 로그 막대로, 겹침 쌍 수를 함께 표시해줘.

라이브 데모 열기 — 군중 분리 2교대 (해시 1 m · 절반씩 번갈아 · 힘 ×2)

추적 방향 표 vs 개별 A* (목표가 1명이면 BFS 한 번)

Flow field vs per-monster A* when every monster chases one player

  • Unity
  • C++
  • BFS

몬스터 전부의 목표가 주인공 한 명이면 몬스터마다 경로를 구할 이유가 없다. 주인공이 1 m 칸을 넘을 때만 BFS로 방향장을 다시 만들고 2 m 안쪽은 직선으로 붙이면, 200마리가 같은 표 하나를 읽고 움직인다.

프롬프트

32×18 격자에 벽을 두고 몬스터 200마리가 달리는 주인공을 쫓게 해줘. 방향 화살표를 2칸 간격으로 그리고, 주인공이 칸을 넘는 순간에만 BFS를 다시 돌려 초당 노드 수를 A* 200마리 × 초당 2회 실측과 막대로 비교해줘. 2 m 안쪽은 필드를 무시하고 주인공에게 직선으로 붙게 해줘.

라이브 데모 열기 — 추적 방향 표 vs 개별 A* (목표가 1명이면 BFS 한 번)

거리별 AI 주기 (14 m 안 60 Hz · 경고 중이면 승격)

Distance-tiered AI updates with telegraph promotion and id-staggered buckets

  • Unity
  • C#
  • Unreal Engine

화면에 보이는 14 m 안만 매 프레임 판단하고 바깥은 15 Hz · 4 Hz로 내린다. 멀리서 공격을 준비하는 놈은 잠시 최상위로 올리고, 번호로 프레임을 나눠 같은 프레임에 몰리지 않게 해야 평균뿐 아니라 최고치도 내려간다.

프롬프트

주인공 중심 동심원에 몬스터 200마리를 뿌리고 0–14 m는 60 Hz, 14–24 m는 15 Hz, 24–40 m는 4 Hz로 판단하게 해줘. 판단하는 프레임의 점을 초록으로 깜빡이고, 공격 경고 중인 놈은 빨강으로 60 Hz 승격해. 같은 프레임에 몰렸을 때 최고 200회와 (번호 + 프레임) mod 주기로 나눴을 때 최고 94회를 막대 그래프로 비교해줘.

라이브 데모 열기 — 거리별 AI 주기 (14 m 안 60 Hz · 경고 중이면 승격)

타격 시점은 교차로 판정 (prev < 16 ≤ k · 어떤 공속에서도 정확히 1회)

Damage-point event by threshold crossing under scaled attack speed

  • Unity
  • Unreal Engine
  • C#

공격 속도가 오르면 애니메이션이 프레임 건너뛰며 진행해 k == 16 같은 검사는 타격을 놓치거나 두 번 낸다. 이전 값이 16 미만이고 지금 값이 16 이상일 때 한 번만 쏘면 어떤 공속에서도 정확히 1회이고, 캔슬 창을 여는 신호도 이 한 번의 이벤트에서 나간다.

프롬프트

40 f 휘두름의 f16에 타격 이벤트를 두고 초당 1.2 · 1.5 · 2.5 · 4회(프레임당 0.8 · 1 · 1.67 · 2.67 f 진행)로 각 30번씩 돌려줘. floor(k) == 16은 이중 6회, 누락 15회, 누락 20회가 나지만 교차 검사는 모두 30/30임을 표로 보여주고, f16 이후 금색 구간에서 이동 입력이 스윙을 끊는 장면을 주인공으로 시연해줘.

라이브 데모 열기 — 타격 시점은 교차로 판정 (prev < 16 ≤ k · 어떤 공속에서도 정확히 1회)

최악 프레임 예산표 (시스템 8개 합 14.2 ms)

Worst-frame budget sheet: per-system caps for 200 monsters at 60 Hz

  • Unity
  • Unreal Engine
  • Profiler

평균이 아니라 200마리가 깨어 있고 한 번에 18마리가 죽는 프레임을 기준으로 시스템마다 상한을 나눠 준다. 합을 16.67 ms의 85 %인 14.2 ms로 잡아 여유를 남기면 상한 없는 26 ms 스파이크가 13.5 ms로 눌린다.

프롬프트

몬스터가 60→200마리로 늘고 70 f마다 18마리가 죽는 8초 구간의 프레임 시간을 시스템 8개(엔진 · AI · 이동 · 전투 · 애니 · 렌더 · VFX · UI) 쌓은 막대로 그려줘. 16.67 ms와 14.2 ms 목표선을 긋고, 상한 없는 경우를 빨간 선으로 겹쳐 최고 25.9 ms · 초과 16 프레임 대 13.5 ms · 0 프레임을 비교하고, 아래에 시스템별 상한 대비 사용량 막대를 넣어줘.

라이브 데모 열기 — 최악 프레임 예산표 (시스템 8개 합 14.2 ms)

상태 이상 평평한 배열 (16 B · 끝과 교체해 삭제)

Status effects as a flat array with swap-remove instead of per-monster slots

  • Unity
  • C#
  • ECS

몬스터마다 상태 이상 칸을 6개씩 두면 대부분 빈 칸인데도 매 프레임 전부 훑어야 한다. 활성 효과만 한 배열에 모으고, 끝난 항목은 마지막 항목으로 덮어 지우면 메모리는 절반 이하, 순회는 활성 개수만큼으로 줄어든다.

프롬프트

몬스터 7마리에 화상 · 냉각 · 중독이 20 f마다 걸리는 장면 옆에 대상 · 종류 · 끝나는 프레임 · 크기를 담은 12칸 배열 표를 실시간으로 보여줘. 효과가 끝나면 마지막 행이 빈자리로 옮겨가는 화살표를 그려줘. 200마리 × 6칸 × 16 B = 19,200 B · 스캔 1,200회 대 512칸 8,192 B · 평균 활성 140회를 막대로 비교해줘.

라이브 데모 열기 — 상태 이상 평평한 배열 (16 B · 끝과 교체해 삭제)

접사는 롤 값으로 저장 (id · 티어 · 롤 = 4 B)

Item affix storage: id, tier and roll byte instead of the final value

  • C++
  • Unity
  • Protobuf

아이템에 최종 수치를 넣으면 밸런스 패치마다 모든 보관함을 변환해야 한다. 접사 id · 티어 · 0–255 롤 바이트만 저장하고 수치는 읽을 때 계산하면 희귀 아이템 한 개가 36 B로 끝나고, 패치는 표만 바꾸면 전원에게 반영된다.

프롬프트

희귀 장검의 접사 6줄을 굴리는 장면을 보여줘. 가중치 띠에서 같은 그룹을 빼고 하나를 고른 뒤 티어와 롤(0–255)을 정하고, 오른쪽에 uid 8 B · 기본 2 B · iLvl 1 B · 등급 1 B + 접사 6 × 4 B = 36 B의 바이트 지도를 칠해줘. 후반에는 범위를 ×1.25로 패치해서 값 = lerp(최소, 최대, 롤 ÷ 255)로 재계산되는 것과 최종 값 저장이 고정되는 것을 비교해줘.

라이브 데모 열기 — 접사는 롤 값으로 저장 (id · 티어 · 롤 = 4 B)

드롭은 서버가 굴림 (터지는 동작 12 f로 왕복 지연 가림)

Server-authoritative drop rolls hidden behind a 12-frame burst animation

  • Unreal Engine
  • C++
  • Netcode

드롭을 클라이언트가 굴리면 메모리 수정으로 전설을 뽑을 수 있으니 서버가 굴려야 한다. 왕복 지연은 몬스터가 터지는 12 f 동작 뒤에 숨기면 200 ms까지 플레이어가 느끼지 못하고, 분당 150회 처치여도 드롭 메시지는 초당 35 B면 된다.

프롬프트

왼쪽에 몬스터를 처치하는 주인공, 오른쪽에 클라이언트 · 서버 수직선의 시퀀스 다이어그램을 그려줘. 적중 입력이 서버로 가서 드롭을 굴리고 14 B 결과가 돌아오는 패킷을 왕복 80 ms로 움직이고, 아이템은 처치 12 f 뒤에 나오게 해. 왕복 40 · 80 · 160 · 240 ms의 프레임 환산과 12 f 초과분(240 ms만 +2.4 f)을 표로 넣어줘.

라이브 데모 열기 — 드롭은 서버가 굴림 (터지는 동작 12 f로 왕복 지연 가림)

바닥 이름표 자리 고정 (새 항목만 빈 자리 찾기)

Stable ground-loot label layout: incremental placement without reshuffling

  • Unity
  • C#
  • UI Toolkit

드롭이 쏟아질 때 이름표를 매번 등급순으로 다시 쌓으면 클릭하려던 글자가 도망간다. 이미 놓인 이름표는 움직이지 않고 새 항목만 빈 자리를 찾게 하면, 겹침 0은 그대로 두고 이벤트당 이동량이 0 px가 된다.

프롬프트

아이템 16개가 하나씩 떨어지고 일부를 줍는 21개 이벤트를 두 패널로 재생해줘. A는 이벤트마다 등급순 전체 재배치, B는 살아 있는 이름표는 고정하고 새 이름표만 위로 9 px씩 올리며 빈 자리를 찾게 해. 이벤트당 이름표 이동량 12.6 px 대 0 px와 겹친 쌍 0을 함께 표시해줘.

라이브 데모 열기 — 바닥 이름표 자리 고정 (새 항목만 빈 자리 찾기)

소켓으로 잇는 던전 (조각 48 m = 타일 2장 · 시연 14조각 · 미리 구운 내비)

Procedural dungeon stitching from socketed 48 m room pieces (two 24 m tiles each) with prebaked navigation

  • Unity
  • Unreal Engine
  • Navmesh

24 m 타일 2장을 묶은 48 m 방 조각을 문 소켓 타입이 맞을 때만 이어 붙이고 남은 소켓은 벽으로 닫는다. 조각마다 내비메시를 미리 구워 두면 런타임 굽기가 필요 없고, 시연의 주 경로 14조각(타일 28장 · 672 m)은 달리기만 134초이며 7분 균열의 1,167 m라면 같은 규칙으로 약 24조각을 잇는다.

프롬프트

11×6 칸에 방 조각(48 m = 24 m 타일 2장)을 왼쪽 시작점부터 하나씩 붙이는 과정을 22 f 간격으로 재생해줘. 막힌 방향은 빨간 테두리로 거절하고, 주 경로 14조각 뒤 3칸마다 곁방을 달아줘. 조각 수 · 불일치 · 곁방 · 주 경로 672 m · 달리기 134초(5 m/s)를 HUD에 표시해줘.

라이브 데모 열기 — 소켓으로 잇는 던전 (조각 48 m = 타일 2장 · 시연 14조각 · 미리 구운 내비)

벽 조각별 가림 판정 (x+y 키 · 겹친 조각만 25 %)

Per-segment occluder test: sort key and screen rectangle decide which wall pieces turn see-through

  • Unity
  • C#
  • Shader

아이소 시점에서 앞벽 전체를 투명하게 하면 방의 형태가 사라진다. 정렬 키 x+y가 주인공보다 크고 화면 사각형이 겹치는 벽 조각만 25 %로 낮추면 방 윤곽은 남고 주인공만 드러난다.

프롬프트

8×8 m 아이소 방에 뒷벽 16칸, 앞벽 16칸, 내부 벽 4칸을 그리고 주인공을 벽 뒤로 돌게 해줘. 벽과 캐릭터를 (x + y) 키로 정렬해 그리고, 앞쪽 벽 20조각에 대해 키가 더 크고 주인공 사각형과 겹치는 조각만 8 f에 걸쳐 불투명도 1 → 0.25로 낮춰 페이드 없는 패널과 비교해줘.

라이브 데모 열기 — 벽 조각별 가림 판정 (x+y 키 · 겹친 조각만 25 %)

스킬을 데이터로 (노드 6개 → 연산표 48 B)

Skill scripting as a data graph compiled to a flat op table

  • Unity
  • C#
  • ScriptableObject

스킬마다 코드를 쓰면 수십 개 스킬이 곧 수십 개 버그가 된다. 시전 · 투사체 · 적중 · 범위 · 피해 · 상태 노드를 데이터로 잇고 8 B 연산표로 컴파일하면 기획자가 스킬을 추가해도 코드는 변하지 않는다.

프롬프트

시전 → 투사체(18 m/s) → 적중 시 → 범위(r 3 m) → 피해 140 % → 화상 120 f 노드 그래프를 위에 그리고, 아래에 실제 시연과 연산표를 나란히 배치해줘. 진행 중인 노드와 연산 행을 금색으로 밝히고, 8 m 비행 26.7 f와 화상 틱을 맞춰 재생하고 연산 6개 × 8 B = 48 B를 표시해줘.

라이브 데모 열기 — 스킬을 데이터로 (노드 6개 → 연산표 48 B)

발동 연쇄 방지 (세대 ≤ 3 · 프레임당 8개)

Proc recursion guard: generation depth and per-frame event queue

  • Unity
  • C++
  • ECS

처치 시 폭발이 또 처치를 내면 한 프레임 안에서 재귀가 끝없이 돌며 빌드 하나가 화면 전체를 지운다. 효과로 난 처치에 세대를 붙여 3세대에서 끊고 남은 폭발은 프레임당 8개씩 큐로 흘리면 스파이크가 사라진다.

프롬프트

몬스터 54마리 격자에서 처치 시 반경 3 m 폭발을 두 패널로 비교해줘. A는 제한 없이 폭발이 폭발을 불러 54회가 한 프레임에 몰려 5.5 ms가 되게 하고, B는 세대 3 초과는 폭발을 큐에 넣지 않고 프레임당 8개만 처리해 폭발 7회 0.2 ms로 끝나게 해. 폭발 1회 비용은 질의 30 µs + 처치 8명 × 9 µs로 계산해 HUD에 표시해줘.

라이브 데모 열기 — 발동 연쇄 방지 (세대 ≤ 3 · 프레임당 8개)

적 동기화 대역폭 (행동 변경만 전송 · 예산 20 KB/s)

Enemy sync at crowd scale: snapshots vs interest area vs behaviour-change events

  • Unreal Engine
  • C++
  • Netcode

200마리의 위치를 초당 20번 보내면 플레이어 1명에게 72 KB/s가 나간다. 관심 영역으로 줄인 뒤에도 남는 양은 위치 대신 목표와 시작 틱만 상태가 바뀔 때 보내고, 클라이언트가 같은 조향을 재생하는 방식으로 줄인다.

프롬프트

주인공 주변 몬스터 200마리를 그리고 화면 14 m, 관심 영역 20 m를 표시해줘. 대역폭을 전원 200 × 18 B × 20 Hz = 72 KB/s, 관심 영역 안의 마리 수 × 18 B × 20 Hz, 상태가 바뀔 때 보내는 14 B 이벤트의 실측 건수로 막대 비교하고 예산선 20 KB/s를 그어줘. 이벤트가 나간 몬스터는 노랗게 깜빡이게 해줘.

라이브 데모 열기 — 적 동기화 대역폭 (행동 변경만 전송 · 예산 20 KB/s)

아이템 이동은 한 트랜잭션 (uid 유일 · 복제 0 · 유실 0)

Saving inventory moves atomically: single transaction with unique item ids

  • C++
  • SQL
  • Unreal Engine

창고로 옮기는 동작을 추가와 삭제 두 번의 저장으로 나누면 그 사이 서버가 죽을 때 복제나 유실이 생긴다. 두 변경을 한 트랜잭션에 넣고 아이템 uid를 유일 키로 두면 어느 시점에 죽어도 합계는 1개다.

프롬프트

가방에서 창고로 아이템을 옮기는 저장 순서 3가지(추가 먼저 · 삭제 먼저 · 한 트랜잭션)를 단계 블록으로 그리고 빨간 번개로 서버 사망 시점을 옮겨가며 합계를 계산해줘. 추가 먼저는 3시점 중 1번 복제, 삭제 먼저는 3시점 중 1번 유실, 트랜잭션은 5시점 모두 정상임을 보여주고, 이동은 즉시 커밋하고 진행 상황만 30초 주기로 저장한다고 표시해줘.

라이브 데모 열기 — 아이템 이동은 한 트랜잭션 (uid 유일 · 복제 0 · 유실 0)

처치 스파이크 분산 (무거운 처리 프레임당 6마리)

Death queue: splitting heavy kill processing across frames

  • Unity
  • C#
  • Profiler

광역기 한 방에 30마리가 죽는 프레임에 드롭 굴림 · 시체 · 불꽃 · 소리를 모두 처리하면 21 ms로 튄다. 번쩍임과 충돌 끄기만 그 프레임에 하고 무거운 처리는 프레임당 6마리씩 큐로 넘기면 5프레임, 83 ms 안에 눈치챌 수 없게 끝난다.

프롬프트

아이소 바닥의 몬스터 30마리를 광역기로 한 번에 처치하는 장면과 프레임 시간 막대를 나란히 그려줘. 기본 11 ms에 가벼운 처리 8 µs × 30은 그 프레임에, 무거운 처리 335 µs는 A는 전부 한 프레임(최고 21.6 ms), B는 프레임당 6마리씩 5프레임(최고 13.6 ms)에 처리해 16.67 ms 선과 비교해줘.

라이브 데모 열기 — 처치 스파이크 분산 (무거운 처리 프레임당 6마리)

깨어 있는 무리만 갱신 (24 m에 깨움 · 34 m에 재움)

Awake set for 1,200 placed monsters: wake and sleep by pack with hysteresis

  • Unity
  • C++
  • ECS

한 층에 1,200마리(균열 7분의 125 % 배치와 같은 규모)를 깔아 두어도 AI와 조향은 깨어 있는 무리만 돌린다. 판정은 무리 단위로 30 f마다, 깨우는 반경과 재우는 반경을 10 m 벌려 경계에서 깜빡이지 않게 하면 전부 돌리는 7.2 ms가 최악 1 ms로 줄어든다.

프롬프트

300 × 144 m 층에 12마리 무리 100개를 홀 여섯 곳 위주로 배치하고 주인공이 1,196 m 경로를 25배속으로 달리게 해줘. 무리 중심이 24 m 안이면 가까운 순서로 예산 200마리까지 깨우고 34 m 밖이면 재우며 8 m 안은 처치로 처리해. 1마리 갱신 6 µs로 전체 7.2 ms와 깨어 있는 수를 비교하고, 최고 168 · 평균 29를 표시하는 아래쪽 그래프를 그려줘.

라이브 데모 열기 — 깨어 있는 무리만 갱신 (24 m에 깨움 · 34 m에 재움)

투사체 풀과 몬스터 해시 (자기 칸만 조회 · 0.30 m/f면 스윕 없음)

Projectile pool querying the monster hash: one cell lookup, no sweep below body diameter

  • Unity
  • C#
  • Jobs

투사체는 256칸 풀에 넣고 끝나면 마지막 칸으로 덮어 할당을 없앤다. 충돌은 분리 조향이 이미 만든 1 m 해시를 그대로 읽어 자기 주변 칸의 몬스터만 재고, 18 m/s는 프레임당 0.30 m로 몸 지름 0.68 m보다 작으니 스윕 판정도 필요 없다.

프롬프트

40 × 24 m에 몬스터 200마리를 두고 중앙의 주인공이 8 f마다 20발을 원형으로 쏘게 해줘. 투사체는 256칸 풀에서 18 m/s로 날고 수명 46 f이며, 몬스터 1 m 해시에서 x ± 0.42, y ± 0.42가 걸치는 칸만 검사해. 전수 비교 투사체 수 × 200과 실제 후보 수를 로그 막대로 나란히 실시간 표시하고 맞은 몬스터는 8 f 흰색으로 칠해줘.

라이브 데모 열기 — 투사체 풀과 몬스터 해시 (자기 칸만 조회 · 0.30 m/f면 스윕 없음)

시체 고리 버퍼 (몸이 화면에 남는 5.6초를 덮는 64칸)

Corpse ring buffer sized from on-screen time and kill bursts

  • Unity
  • C#
  • Rendering

시체는 오래된 것부터 덮어쓰는 고정 배열 하나면 된다. 크기는 평균이 아니라 몸이 화면을 벗어나는 5.6초 동안 몰리는 처치 수로 정해야, 눈앞의 시체가 사라지는 일이 없고 64칸 1 KB로 끝난다.

프롬프트

주인공이 5 m/s로 달리며 16초 동안 10마리 무리를 3연속씩 처치해 5초에 30킬이 몰리는 장면을 위아래 두 줄로 재생해줘. 위는 16칸, 아래는 64칸 고리 버퍼이고 각 슬롯과 쓰기 위치를 칸 띠로 표시해. 화면 안에서 지워진 시체를 빨갛게 터뜨려 16칸 28구 대 64칸 0구를 보여주고, 64 × 16 B = 1,024 B를 적어줘.

라이브 데모 열기 — 시체 고리 버퍼 (몸이 화면에 남는 5.6초를 덮는 64칸)

무리 활성화는 화면 밖 18 m부터 (프레임당 2마리)

Pack activation lead distance and per-frame budget beyond the screen edge

  • Unity
  • C#
  • Object Pool

화면 끝에서 12마리를 한 프레임에 켜면 눈앞에 튀어나오면서 프레임도 튄다. 화면 14 m + 무리 반경 2 m + 등장 23 f 동안 달리는 2 m를 더한 18 m에서 시작해 프레임당 2마리씩 켜면 스파이크와 팝인이 함께 사라진다.

프롬프트

달리는 주인공 앞에 12마리 무리 3개를 두고 활성화 지점을 두 줄로 비교해줘. A는 14 m에서 한 프레임에 전부(11 + 0.9 × 12 = 21.8 ms, 화면 안 등장 36마리), B는 18 m에서 프레임당 2마리에 18 f 솟아오르기(12.8 ms, 화면 안 등장 0마리)로 해. 화면 경계선과 프레임 비용 그래프를 함께 그려줘.

라이브 데모 열기 — 무리 활성화는 화면 밖 18 m부터 (프레임당 2마리)

사수의 발사 판정은 화살 경로와 같은 칸 순회로 (아니면 14 %가 벽 너머로 샌다)

Ranged monster firing check: grid traversal matching the arrow path through diagonal walls

  • Unity
  • C++
  • Tilemap

사수의 발사 판정을 칸 몇 개만 찍는 검사로 하면 대각선으로 이어진 벽 틈을 그대로 통과해, 화살은 막히는데 사수는 계속 쏜다. 화살과 같은 칸 순회를 쓰고 칸 모서리를 지날 때 양옆을 모두 검사하면 헛발사가 사라진다.

프롬프트

18 × 11칸에 대각 벽을 놓고 사수 5명이 움직이는 주인공을 향해 12 f마다 시야선을 판정하게 해줘. 왼쪽은 브레젠험, 오른쪽은 격자 순회(모서리 통과 시 양옆 칸 검사)로 그리고, 벽을 뚫었는데 보인다고 나온 선을 빨간색으로 표시해 200회 중 28회(14 %)를 HUD에 적어줘.

라이브 데모 열기 — 사수의 발사 판정은 화살 경로와 같은 칸 순회로 (아니면 14 %가 벽 너머로 샌다)

벽 앞 넉백은 8 f 축 분리 (벽 박힘 0 · X 먼저 Y 나중)

Knockback against tiles: eight per-axis steps instead of one 0.5 m teleport

  • Unity
  • C#
  • Tilemap

0.5 m를 한 번에 옮기면 몸 반지름 0.34 m가 벽에 박혀 AI가 다시는 못 나온다. 프레임당 0.0625 m씩 8번 나눠 축마다 따로 벽을 검사하면 막힌 축만 버리고 남은 축으로 미끄러진다. 넉백 8 f 동안 몬스터끼리의 충돌은 끄고 분리 조향이 뒤에 정리하게 둔다.

프롬프트

9 × 7칸 방에서 주인공이 40 f마다 2.5 m 안의 몬스터 9마리를 밀어내게 해 두 패널로 비교해줘. A는 즉시 0.5 m 이동으로 8초 동안 3마리가 벽에 박혀 멈추게 하고, B는 8 f에 걸쳐 X 먼저 Y 나중으로 벽을 검사해 0마리 · 평균 0.49 m를 표시해줘.

라이브 데모 열기 — 벽 앞 넉백은 8 f 축 분리 (벽 박힘 0 · X 먼저 Y 나중)

광역 적중 보고는 비트열로 (대상 7명부터 25 B)

Area hit report: slot bitset beats an id list from seven targets

  • Unreal Engine
  • C++
  • Netcode

광역 한 번에 맞은 몬스터 id를 4 B씩 보내면 64명에 257 B다. 깨울 때 서버와 맞춘 200칸 슬롯 표를 쓰면 몇 명을 맞혀도 비트열 25 B로 끝나므로, 첫 바이트로 형식을 골라 6명까지는 목록, 7명부터는 비트열을 보낸다.

프롬프트

몬스터 200마리 위에 대상이 12 · 32 · 64명이 되도록 범위를 터뜨리고 200칸 슬롯 비트 표에서 맞은 칸을 금색으로 켜줘. 패킷 크기를 헤더 1 B + 4 B × 대상과 헤더 1 B + 25 B 두 직선으로 그려 교차점 7명을 표시하고 32명 기준 80 %를 적어줘.

라이브 데모 열기 — 광역 적중 보고는 비트열로 (대상 7명부터 25 B)

피해 계산 둘로 나누기 (공격자 쪽 시전당 1번 · 대상 쪽만 반복)

Damage pipeline split: attacker terms once per cast, target terms per row

  • Unity
  • C++
  • ECS

모디파이어 40개를 더하는 공격자 쪽 계산을 대상마다 반복하면 64명에 3,008번 연산이 든다. 시전당 한 번 묶어 두고 치명 · 저항 · 방어 · 취약만 대상별로 돌리면 299번이고, 대상 쪽은 평평한 배열을 한 줄씩 읽으면 된다.

프롬프트

위쪽에 기본 피해 → 스킬 배율 → 증가 합산(모디파이어 40개) → 곱연산이 시전당 한 번 흘러가고, 그 값이 대상 12 · 32 · 64명의 표로 퍼져 치명 5 % · 저항 · 방어 · 취약 4열을 통과하는 그림을 그려줘. 연산 수 (40 + 3 + 4) × 대상 = 564 · 1,504 · 3,008 대 43 + 4 × 대상 = 91 · 171 · 299를 막대로 비교해줘.

라이브 데모 열기 — 피해 계산 둘로 나누기 (공격자 쪽 시전당 1번 · 대상 쪽만 반복)

안개를 비트로 저장 (256 × 256 = 8 KB · 줄 단위 OR)

Fog-of-war bitfield with per-row span OR only when the player changes cell

  • Unity
  • C++
  • Bitfield

탐험 지도는 칸당 1비트면 256 × 256칸이 8 KB다. 시야 원을 칸마다 찍지 않고 줄별 시작과 끝 비트를 만들어 64비트 워드에 OR하고, 주인공이 칸을 넘을 때만 갱신하면 매 프레임 칸 쓰기의 200분의 1도 안 된다.

프롬프트

안개가 걷히는 미니맵과 비트 지도 일부를 나란히 그리고 바뀐 줄을 금색으로 깜빡여줘. 시야 반경 14칸이면 613칸 · 29줄이고 줄 단위 OR은 칸 이동(5회/s)마다 평균 38.1워드로 초당 191회, 칸 × 매 프레임은 초당 36,780회임을 로그 막대로 비교해줘.

라이브 데모 열기 — 안개를 비트로 저장 (256 × 256 = 8 KB · 줄 단위 OR)

바닥 장판 풀 나누기 (내 그을음 24칸 + 위험 원 8칸)

Pooled ground decals with a reserved lane for danger circles

  • Unity
  • C#
  • Rendering

바닥 표시를 한 풀에 넣고 오래된 것부터 지우면 빠른 스킬의 그을음이 몬스터의 위험 원을 밀어내 맞고 나서야 알게 된다. 위험 원 전용 8칸을 따로 두면 장식이 아무리 많아도 위험 표시는 끝까지 살아남는다.

프롬프트

그을음이 초당 42개, 위험 원이 초당 3개(수명 30 · 45 · 60 f) 나오는 8초를 두 패널로 재생해줘. A는 32칸 하나를 가장 오래된 것부터 덮어써 위험 원 8개 중 5개가 끝나기 전에 사라지고, B는 그을음 24칸 + 위험 원 8칸으로 나눠 0개가 사라짐을 표시해줘.

라이브 데모 열기 — 바닥 장판 풀 나누기 (내 그을음 24칸 + 위험 원 8칸)

루트 필터는 드롭 순간 한 번 (종류별 표 · 결과 1 B 저장)

Loot filter evaluation baked per item class, cached as one style byte

  • Unity
  • C#
  • Data-driven

규칙 120줄을 바닥 아이템마다 매 프레임 돌리면 초당 9만 번 넘게 비교한다. 필터를 읽을 때 아이템 종류별 규칙 표로 컴파일하고, 드롭 순간 한 번 평가해 결과를 스타일 1바이트로 저장하면 비교는 초당 8회로 준다.

프롬프트

왼쪽에 규칙 120줄을 위에서부터 훑는 프레임별 스캔, 오른쪽에 종류 16칸의 규칙 표로 떨어진 아이템이 자기 칸만 훑어 스타일 바이트를 받는 장면을 그려줘. 평균 비교 37.6줄 × 40개 × 60 Hz = 90,304회/s 대 3.2줄 × 드롭 2.5개/s = 8회/s를 로그 막대로 비교해줘.

라이브 데모 열기 — 루트 필터는 드롭 순간 한 번 (종류별 표 · 결과 1 B 저장)

이동 복제는 목적지 8 B만 (위치 스트림의 13 %)

Movement replication by destination packets instead of a position stream

  • Unreal Engine
  • C++
  • Netcode

누른 채 이동을 위치 스트림으로 보내면 초당 360 B가 나가지만, 서버와 클라이언트가 같은 조향을 돌리면 목적지만 보내도 위치가 맞는다. 커서가 0.5 m 움직이고 10 f가 지났을 때만 8 B를 보낸다. 지연으로 생기는 최대 1.09 m 차이는 보정 임계 1.5 m 안에 있어 끌어당김이 없다.

프롬프트

15×9칸에서 커서를 따라 5 m/s로 달리는 주인공과 편도 5 f 뒤의 서버 복제본을 파란 원으로 겹쳐 그려줘. 위치 20 Hz × 18 B = 360 B/s 스트림 눈금과, 커서가 10 f · 0.5 m 조건을 넘을 때만 나가는 목적지 8 B 눈금 48 B/s를 타임라인에 비교하고, 서버-클라 최대 차 1.09 m · 보정 0회를 표시해줘.

라이브 데모 열기 — 이동 복제는 목적지 8 B만 (위치 스트림의 13 %)

바닥 청크 16 m · ±1칸 (구멍 0 · 읽기 18 f보다 여유 24 f)

Ground chunk size for a 5 m/s run: 16 m ring against load latency

  • Unity
  • C#
  • Addressables

화면 반경 14 m에서 16 m 청크 ±1이면 칸을 넘는 순간 앞에 2 m가 남아 달리기로 24 f의 여유가 생기고, 읽기 18 f가 그 안에 들어온다. 8 m ±2는 구멍이 없지만 파일 요청이 3.3배이고, 32 m는 상주 면적이 4배라 16 m를 고른다.

프롬프트

달리는 주인공 주변에 16 m 청크를 칠해 읽는 중은 금색, 준비됨은 청록으로 재생해줘. 칸을 넘을 때만 다음 줄을 요청하고 읽기 18 f 뒤 2 f에 1개씩 합치게 해. 12초 경로의 표를 8 m ±1(구멍 720 f) · 8 m ±2(0 f · 요청 200/분 · 2,240 m²) · 16 m ±1(0 f · 60/분 · 3,840 m²) · 32 m ±1(0 f · 30/분 · 15,360 m²)로 넣어줘.

라이브 데모 열기 — 바닥 청크 16 m · ±1칸 (구멍 0 · 읽기 18 f보다 여유 24 f)

골드 더미 합치기 (착지 때 1 m 안이면 합산 · 자석 4 m)

Gold pile coalescing at landing with a 4 m pickup magnet

  • Unity
  • C#
  • Object Pool

처치마다 골드를 따로 두면 이름표와 자석 거리 계산이 화면 가득 늘어난다. 착지하는 순간 1 m 안의 더미와 값을 합치고 크기만 키우면 금액은 같은데 슬롯은 40 % 이상 줄고, 판정은 착지 때 한 번이면 된다.

프롬프트

38 × 22 m 필드에서 34 f마다 골드 12개가 떨어지고 주인공이 천천히 돌아다니며 4 m 자석으로 빨아들이는 장면을 두 패널로 비교해줘. A는 더미를 그대로, B는 착지 때 1 m 안 더미에 값을 합치고 흰 테로 깜빡이게 해. 10초 동안 최고 동시 138개 대 78개, 평균 71개 대 42개를 표시해줘.

라이브 데모 열기 — 골드 더미 합치기 (착지 때 1 m 안이면 합산 · 자석 4 m)

균열 진행도 표시는 뒤로 가지 않는다 (서버 값 + 대기분의 최댓값)

Server-counted rift progress with a client bar that never rewinds

  • Unreal Engine
  • C++
  • Netcode

진행도는 서버가 세되 처치마다 80 ms를 기다리면 답답하니 클라이언트가 먼저 올린다. 거절된 처치를 그대로 빼면 막대가 뒤로 움찔하므로 서버 값 + 미확인분의 최댓값으로 표시를 묶고, 100 % 연출은 서버 확정 뒤에만 터뜨린다.

프롬프트

8초 동안 무리를 잡으며 70킬(거절 4건)이 서버 왕복 5 f로 처리되는 진행도 곡선을 낙관 표시 · 서버 값 · 되돌리지 않는 표시 셋으로 겹쳐 그려줘. 거절로 뒤로 간 횟수 4회 대 0회, 집계 메시지 5 Hz × 6 B = 30 B/s를 표시하고 아래에 막대 2개로 실제 움직임을 보여줘.

라이브 데모 열기 — 균열 진행도 표시는 뒤로 가지 않는다 (서버 값 + 대기분의 최댓값)

큰 체력은 정수로 (float32면 12 · 15가 사라지고 20이 32로)

Monster HP storage: float32 quantisation against int64 at 300 million

  • C++
  • Unity
  • Numeric

후반 체력이 2^24를 넘으면 float32의 눈금이 1보다 커져 작은 피해가 반올림으로 사라진다. 3억이면 눈금 32라 12와 15는 0이 되고 20은 32로 부풀기 때문에, 체력과 피해 합계는 정수 64비트로 저장하고 숫자 표시만 축약한다.

프롬프트

체력 3억 몬스터에 12 · 15 · 20의 지속 피해가 30 f마다 들어가는 8초를 재생해줘. int64로는 합 236이 깎이고 float32로는 128이 깎이는 수치를 나란히 보여주고, 3억의 32비트 부호 · 지수 · 가수를 칠한 뒤 눈금 32와 2^24 = 16,777,216 한계를 적어줘.

라이브 데모 열기 — 큰 체력은 정수로 (float32면 12 · 15가 사라지고 20이 32로)

주인공은 몬스터에 막히지 않는다 (몬스터가 프레임당 0.15 m 비킴)

Hero movement priority through a crowd: monsters yield, walls block

  • Unity
  • C#
  • Character Controller

주인공과 몬스터가 서로 밀어내면 공격 중인 몬스터가 벽이 되어 시작 3초 만에 무리 앞에서 끼어 버린다. 주인공 쪽 충돌을 없애고 몬스터만 프레임당 최대 0.15 m 비키게 하면 5 m/s가 그대로 유지되고, 주인공을 막는 것은 벽뿐이다.

프롬프트

몬스터 60마리(몸 r 0.34)가 공격 자세로 서 있는 5 m 두께 띠를 주인공(r 0.40)이 5 m/s로 통과하게 두 줄로 비교해줘. A는 서로 밀어내기로 16.5 m 중 5.0 m에서 326 f 막히고, B는 몬스터만 프레임당 최대 0.15 m 밀려나 198 f(3.3 s)에 통과하게 해. 전진 거리와 막힌 프레임을 표시해줘.

라이브 데모 열기 — 주인공은 몬스터에 막히지 않는다 (몬스터가 프레임당 0.15 m 비킴)

장판 질의는 12 f 주기로 위상을 나눈다 (번호로 분산 · 최고 22 µs)

Persistent zone queries spread over a 12-frame phase wheel

  • Unity
  • C#
  • Jobs

장판 8개가 매 프레임 범위 질의를 하면 초당 10.6 ms가 든다. 12 f에 한 번만 재고 피해를 그만큼 곱해 주면 0.88 ms가 되는데, 전부 같은 프레임에 하면 스파이크가 그대로니 장판 번호로 12칸 위상에 흩뿌린다.

프롬프트

바닥 장판 8개와 12칸 위상 시계를 그리고 현재 프레임에 질의하는 장판만 흰 테로 깜빡여줘. 질의 1회 22 µs(질의 6 + 16명)로 매 프레임 176 µs, 12 f 일괄 176 µs, (번호 + 프레임) mod 12로 나누면 최고 22 µs를 비교하는 스크롤 막대를 넣어줘. 틱 피해는 초당 피해 × 12 ÷ 60으로 맞춰줘.

라이브 데모 열기 — 장판 질의는 12 f 주기로 위상을 나눈다 (번호로 분산 · 최고 22 µs)

서버 쿨다운 검사 허용 6 f + 빚 (거절 0 · 일찍 보내도 이득 없음)

Server cooldown validation: 6-frame tolerance repaid as cooldown debt

  • Unreal Engine
  • C++
  • Netcode

클라이언트가 정확히 끝 틱에 보내도 지터 때문에 서버에는 일찍 도착해 허용치 0이면 37 %가 거절된다. 6 f를 허용하되 받아 준 만큼 다음 끝 틱을 뒤로 밀면 정직한 플레이어는 거절이 없고, 4 f 일찍 보내는 조작의 이득도 사라진다.

프롬프트

4 s 스킬 400회 전송의 서버 판정을 표로 비교해줘. 허용 0 f는 거절 148회에 재전송 8 f로 간격 244.7 f, 허용 6 f + 빚은 거절 0회 240.0 f, 빚 없이 4 f 일찍 보내면 236.2 f(+1.6 %), 빚이 있으면 240.2 f(이득 없음)이고 수락과 거절을 타임라인 눈금으로 그려줘.

라이브 데모 열기 — 서버 쿨다운 검사 허용 6 f + 빚 (거절 0 · 일찍 보내도 이득 없음)

끼인 몬스터 구출 (120 f에 0.3 m 미만 · 화면 밖은 워프)

Stuck monster rescue: progress test, on-screen A* and off-screen warp

  • Unity
  • C#
  • NavMesh

방향장과 분리 조향만 쓰면 오목한 벽 안에 몬스터가 박혀 슬롯만 차지한다. 120 f 동안 0.3 m도 못 가면 끼임으로 보고, 화면 밖이면 플레이어 주변 15–17 m로 옮기고 화면 안이면 그 몬스터만 프레임당 1회 A*를 태운다.

프롬프트

64 × 40 m 맵에 ㄷ자 벽을 놓고 몬스터 40마리가 달리는 주인공을 직선 추격하게 두 패널로 비교해줘. A는 구출 없이 끼인 몬스터가 빨갛게 쌓이게 하고, B는 120 f에 0.3 m 미만이면 화면 밖(14 m 초과)은 15–17 m로 워프, 안쪽은 프레임당 1회 A* 최대 14칸으로 빠져나오게 해. 끼인 수와 호출 횟수를 표시해줘.

라이브 데모 열기 — 끼인 몬스터 구출 (120 f에 0.3 m 미만 · 화면 밖은 워프)