따알깍PROMPT DICT 앱으로 열기

게임 개발 · 엔진 · 프로그래밍 · AI · 엔진 · 수학 · 툴

게임 엔진 구조 · 프로그래밍 패턴 Game engine architecture & programming patterns

고정 타임스텝, ECS 아키타입, 오브젝트 풀, SAT·GJK 충돌, 잡 시스템, 더티 플래그처럼 게임이 내부에서 돌아가는 구조. 작은 게임이 실제로 돌아가는 동안 메모리 블록·타임라인·큐가 함께 움직이는 살아 있는 다이어그램으로 보여 준다.

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

카드 목록 57개
  1. 가변 dt 물리의 프레임레이트 의존
  2. 고정 타임스텝 어큐뮬레이터
  3. 렌더 보간 vs 외삽 (알파 블렌딩)
  4. 죽음의 나선 (스텝 상한)
  5. 프레임 페이싱과 Vsync 저더
  6. 게임·렌더·GPU 스레드 파이프라이닝
  7. 프레임 예산 프로파일러 플레임 그래프
  8. 잡 시스템 의존성 그래프
  9. ECS 아키타입 청크
  10. 스파스 셋 컴포넌트 저장소
  11. AoS vs SoA 캐시 라인
  12. 오브젝트 풀 vs GC 스파이크
  13. 프레임 선형 할당자
  14. 세대 카운터 핸들 (댕글링 참조 방지)
  15. 공간 해시 그리드 브로드페이즈
  16. 스윕 앤 프룬 (정렬 끝점)
  17. 분리축 정리 (SAT) 투영
  18. GJK 심플렉스 진화
  19. EPA 관통 깊이 확장
  20. 연속 충돌 검출 (터널링 방지)
  21. 적분기 비교: 에너지 드리프트
  22. 순차 임펄스 반복 횟수와 웜 스타트
  23. 타일 충돌 축 분리 해결
  24. 옵저버 패턴 (서브젝트 알림)
  25. 이벤트 큐 링 버퍼 (요청 병합)
  26. 커맨드 패턴 · 유닛 명령 큐
  27. 업데이트 순서와 1프레임 지연
  28. 더블 버퍼 (스캔 순서 오염 방지)
  29. 더티 플래그 (씬 그래프 변환)
  30. 서비스 로케이터와 널 서비스
  31. 플라이웨이트 숲 (공유 모델 + 인스턴스)
  32. 타입 오브젝트 (데이터 정의 종족)
  33. 바이트코드 스택 VM
  34. 코루틴 시퀀스 (yield 재개 지점)
  35. 에셋 스트리밍 링과 IO 큐
  36. 비동기 씬 로딩 파이프라인
  37. 세이브 파일 버전 마이그레이션
  38. 입력 컨텍스트 스택
  39. 핫 리로드 (상태 유지 반영)
  40. 데이터 주도 밸런싱 (시트 → 스탯)
  41. 로컬라이제이션 문자열 테이블
  42. 상태 패턴 vs 거대한 switch 문
  43. 상속 계층 vs 컴포넌트 조합
  44. 메시지 버스 · 토픽 구독 (와일드카드)
  45. 씬 그래프 순회 · 재부모화
  46. 리소스 참조 카운팅 · 순환 누수
  47. 스레드 간 큐 · 뮤텍스 vs 락프리 링
  48. 결정론 · 부동소수점 연산 순서
  49. 난수 스트림 분리 · 시드 트리
  50. 타이머 휠 · 게임 시간 vs 실제 시간
  51. 모듈 의존성 · 로드 순서 · 순환 검출
  52. 콘솔 변수 · 설정 우선순위 계층
  53. 크래시 핸들링 · 미니덤프 · 심볼화
  54. 플랫폼별 메모리 예산
  55. 문자열 인터닝 · 해시 이름 ID
  56. 리플렉션 · 자동 인스펙터 · 직렬화
  57. 게임 루프 구조 비교 (단일 · 렌더 스레드 · 태스크 그래프)

가변 dt 물리의 프레임레이트 의존

Frame-rate dependent physics with variable delta time (apex height vs dt)

  • Unity
  • Godot
  • Canvas

같은 점프 코드가 15·30·120 FPS에서 서로 다른 최고점에 도달해, 고프레임에서만 먹을 수 있는 코인이 생기는 버그를 보여 준다. 물리를 렌더 프레임 dt로 적분할 때의 함정을 설명할 때 쓴다.

프롬프트

같은 반-암시적 오일러 점프(vy += g·dt; y += vy·dt, v0 = −330px/s, g = 900px/s²)를 15·30·120 FPS 세 레인에서 동시에 돌려, 최고점이 50px·55px·59px로 달라지고 57px 높이 코인을 120 FPS 레인만 먹는 장면을 Canvas로 만들어줘. 각 레인에 물리 스텝마다 점 궤적, 최고점 점선과 수치, dt 틱 스트립을 표시하고 하단에 apex ≈ v²/2g − |v|·dt/2 공식을 띄워줘.

라이브 데모 열기 — 가변 dt 물리의 프레임레이트 의존

고정 타임스텝 어큐뮬레이터

Fixed timestep with accumulator ("Fix Your Timestep")

  • Unity
  • Godot
  • C++

들쭉날쭉한 렌더 프레임 시간이 어큐뮬레이터에 쌓였다가 16.67ms 고정 틱으로 0·1·2번씩 소비되는 과정을 타임라인으로 보여 준다. 결정적·안정적 물리 루프를 설계할 때 쓴다.

프롬프트

Glenn Fiedler의 Fix Your Timestep 방식으로 acc += frameTime; while(acc >= dt){ step(dt); acc -= dt; } 루프를 시각화해줘. 7~38ms로 흔들리는 렌더 프레임 줄과 dt = 16.67ms 고정 틱 줄을 위아래로 스크롤시키고, 프레임마다 소비한 스텝 수(×0/×1/×2)와 틱→프레임 연결선, dt·2dt 눈금이 있는 어큐뮬레이터 막대, 현재 실행 줄이 하이라이트되는 코드 패널을 함께 그려줘.

라이브 데모 열기 — 고정 타임스텝 어큐뮬레이터

렌더 보간 vs 외삽 (알파 블렌딩)

Render state interpolation vs extrapolation (alpha = acc / dt)

  • Unity
  • Godot
  • Canvas

10Hz 물리를 60fps로 그릴 때 스냅·보간·외삽 세 방식의 차이(끊김, 1틱 지연, 벽 관통)를 나란히 비교한다. 고정 스텝 물리 위에 부드러운 렌더링을 얹을 때 쓴다.

프롬프트

시뮬레이션 10Hz(dt = 100ms), 렌더 60fps에서 벽 사이를 105px/s로 왕복하는 공을 세 레인에 그려줘: ① 현재 상태 그대로(계단 끊김) ② lerp(prev, curr, α), α = acc/dt(1틱 지연, 매끈) ③ curr + v·α·dt 외삽(충돌을 무시해 벽을 최대 10px 관통하고 팝). prev/curr 상태를 점선·실선 원으로, 오른쪽에 α 톱니파 그래프와 틱 스트립을 표시해줘.

라이브 데모 열기 — 렌더 보간 vs 외삽 (알파 블렌딩)

죽음의 나선 (스텝 상한)

Spiral of death and max-steps-per-frame clamp

  • Unity
  • Unreal
  • C++

물리 한 스텝 비용이 dt를 넘는 순간 프레임마다 스텝이 늘어 프레임이 폭주하는 현상과, 스텝 상한으로 슬로모션으로 대신 버티는 해법을 프레임 막대로 비교한다. 물리 부하 스파이크 대책을 세울 때 쓴다.

프롬프트

스텝 비용이 4ms에서 점점 올라 16.67ms를 넘는 고정 스텝 루프를 두 레인으로 비교해줘: ① 무제한 while(acc>=dt) — 스텝 수가 1→2→3→8로 늘며 프레임 시간이 폭주해 FREEZE ② 프레임당 최대 2스텝, 초과 누적 시간은 버림(frameTime도 250ms로 캡) — fps는 유지되고 게임 시간이 0.6× 슬로모션. 프레임마다 렌더(회색)+스텝(주황) 스택 막대, 16.7/33.3ms 기준선, 미니 게임 화면에 steps/fps/cost를 표시해줘.

라이브 데모 열기 — 죽음의 나선 (스텝 상한)

프레임 페이싱과 Vsync 저더

Frame pacing on a fixed-refresh display (vsync judder)

  • Unity
  • Android
  • Vulkan

60Hz 화면에서 60·45·30fps(균일)·30fps(비균일) 프레임이 실제로 몇 vsync 동안 보이는지와 그로 인한 위치 오차(저더)를 나란히 보여 준다. 프레임 상한·페이싱 라이브러리 설정 근거를 설명할 때 쓴다.

프롬프트

60Hz(16.7ms) vsync 타임라인 위에 네 레인을 0.25× 슬로모션으로 그려줘: 60fps(매 vsync), 45fps(22.2ms 렌더가 17/17/33ms로 표시), 30fps 페이싱(33/33/33), 30fps 비균일(17/50ms 교대, 평균만 30). 각 레인에서 일정 속도로 움직이는 공의 실제 표시 위치와 이상적 위치(점선 원)의 차이를 빨간 선으로, 아래에 프레임별 표시 시간 블록을 표시해 고른 30fps가 출렁이는 45fps보다 부드러운 이유를 보여줘.

라이브 데모 열기 — 프레임 페이싱과 Vsync 저더

게임·렌더·GPU 스레드 파이프라이닝

Pipelined game / render / GPU frames (N, N−1, N−2) and input latency

  • Unreal
  • Unity
  • C++

게임 스레드가 프레임 N을, 렌더 스레드가 N−1을, GPU가 N−2를 동시에 처리하는 계단식 파이프라인과 그 결과 생기는 3프레임 입력 지연을 보여 준다. 멀티스레드 엔진의 처리량과 지연 트레이드오프를 설명할 때 쓴다.

프롬프트

GAME(12ms)·RENDER(10ms)·GPU(14ms)·DISPLAY 4개 레인을 60Hz 슬롯 위에 계단식으로 흘려 프레임 N, N−1, N−2가 동시에 처리되는 파이프라인을 그려줘. 프레임 3의 게임 슬롯 중 버튼 입력이 들어오면 그 프레임만 하이라이트해 디스플레이에 도달할 때까지 따라가고, 입력→표시 지연(≈45ms, 입력 시점에 따라 2.7~3.7프레임) 화살표와 그 순간에야 점프하는 미니 캐릭터를 함께 보여줘.

라이브 데모 열기 — 게임·렌더·GPU 스레드 파이프라이닝

프레임 예산 프로파일러 플레임 그래프

Frame budget profiler with flame graph drill-down

  • Unity
  • Unreal
  • Tracy

프레임 시간 막대에서 16.67ms 예산을 넘은 스파이크를 클릭하면 Update/AI/Physics/Render 계층 구간이 플레임 그래프로 펼쳐져 원인 구간을 찾는다. 성능 병목을 찾는 프로파일링 워크플로를 보여 줄 때 쓴다.

프롬프트

최근 48프레임 시간 막대 그래프(16.67ms 예산 점선, 초과 프레임은 빨강)를 스크롤시키고, 커서가 31.2ms 스파이크 프레임을 클릭하면 Frame→Update(22.4)→AI(14.1)→Replan(11.8ms) 식의 중첩 플레임 그래프가 0.5초 easeOut으로 펼쳐지며 핫스팟이 맥동하게 해줘. 이후 정상 프레임(13.1ms)을 클릭해 비교하고, x축은 0~33.3ms, 예산선을 세로로 그어줘.

라이브 데모 열기 — 프레임 예산 프로파일러 플레임 그래프

잡 시스템 의존성 그래프

Job system: dependency graph scheduled on worker threads

  • Unity
  • Unreal
  • C++

프레임 작업을 Input→AI×4→Anim, Broad→Narrow×3→Solve→Skin→Cull→Submit 같은 DAG 잡으로 쪼개 4개 워커 스레드에 배치하는 과정을 그래프와 스레드 타임라인으로 보여 준다. 멀티코어 엔진의 프레임 병렬화를 설명할 때 쓴다.

프롬프트

17개 잡(각 0.6~1.8ms)과 의존성 간선으로 된 DAG를 왼쪽→오른쪽 층으로 그리고, 크리티컬 패스 우선 리스트 스케줄링으로 4개 워커 레인에 배치한 타임라인을 플레이헤드로 재생해줘. 실행 중 노드는 워커 색으로 빛나고 완료된 의존 간선은 초록으로 바뀌며, 하단에 1스레드 20.3ms vs 4워커 8.2ms(×2.5) 비교 막대을 표시해줘(Unity Job System/Naughty Dog 파이버 잡 시스템 개념).

라이브 데모 열기 — 잡 시스템 의존성 그래프

ECS 아키타입 청크

ECS archetype chunks: structural change moves entities between tables

  • Unity DOTS
  • flecs
  • C++

불타는 상태(Burning) 컴포넌트가 붙는 순간 엔티티가 [Pos,Vel,HP] 아키타입에서 [Pos,Vel,HP,Burn] 아키타입 청크로 이동하고, 빈자리는 마지막 엔티티가 메우는(swap-back) 메모리 구조를 게임과 함께 보여 준다. ECS 구조 변경 비용과 쿼리 순회를 설명할 때 쓴다.

프롬프트

탑다운 아레나에서 마법사가 파이어볼을 쏘면 맞은 유닛에 Burning 컴포넌트가 추가되어, 오른쪽 청크 테이블에서 해당 행이 아키타입 A(Entity/Pos/Vel/HP, 용량 6)에서 아키타입 B(+Burn)로 0.55초 동안 날아가고 A의 마지막 행이 빈칸으로 swap-back 되게 해줘. BurnSystem이 query<HP,Burn>로 청크 B만 순회하는 스캔 커서와 줄어드는 HP 셀, 불이 꺼지면 다시 A로 돌아오는 흐름까지 Unity Entities 개념으로 그려줘.

라이브 데모 열기 — ECS 아키타입 청크

스파스 셋 컴포넌트 저장소

Sparse set component storage (EnTT-style swap-and-pop)

  • EnTT
  • C++
  • Rust

sparse[엔티티]→dense 인덱스 배열과 빈칸 없는 dense 컴포넌트 배열로 O(1) 추가·삭제·조회와 연속 순회를 동시에 얻는 구조를 보여 준다. 엔티티별로 자주 붙었다 떨어지는 상태 컴포넌트를 저장할 때 쓴다.

프롬프트

마을 주민 12명(e0~e11)에게 독(Poison) 컴포넌트가 add/remove 되는 0.6초 간격 시퀀스에 맞춰 sparse 배열(12칸)과 dense 배열(엔티티 ID + dmg 값)을 그려줘. 추가는 dense 끝에 붙고, 삭제는 마지막 원소를 빈자리로 옮기고 sparse 포인터를 갱신하는 swap-and-pop 애니메이션(0.45초 easeInOut)과 sparse→dense 베지어 화살표, 연속 순회 커서를 EnTT 스타일로 보여줘.

라이브 데모 열기 — 스파스 셋 컴포넌트 저장소

AoS vs SoA 캐시 라인

AoS vs SoA memory layout and cache-line utilisation

  • C++
  • Unity Burst
  • Rust

이동 시스템이 px,py,vx,vy만 필요할 때 64바이트 구조체 배열(AoS)은 캐시 라인의 25%만 쓰고, 필드별 배열(SoA)은 100%를 써서 같은 메모리 대역폭으로 4배 많은 유닛을 갱신하는 모습을 보여 준다. 데이터 지향 설계로 핫 루프를 최적화할 때 쓴다.

프롬프트

64바이트 struct Unit{px,py,vx,vy,hp,mp,ai[4],name[4],flags,color} 64개를 AoS 레인에서는 유닛당 캐시 라인 1개(사용 16/64B=25%), SoA 레인에서는 px[]/py[]/vx[]/vy[] 라인당 16개 값(100%)으로 16칸 슬롯 그리드로 그려줘. 같은 속도(초당 2.7라인)로 라인을 로드하며 위쪽 유닛 무리가 갱신되어 켜지게 해, 6초 동안 SoA는 64개를 끝내고 AoS는 16개에 그치는 4배 차이 경주를 Mike Acton식 데이터 지향 설계 관점으로 보여줘.

라이브 데모 열기 — AoS vs SoA 캐시 라인

오브젝트 풀 vs GC 스파이크

Object pooling vs garbage-collection frame spikes

  • Unity
  • C#
  • Godot

총알을 매번 new로 만들면 힙에 가비지가 쌓이다 GC가 돌며 프레임이 60ms 가까이 튀고, 32칸 풀에서 재사용하면 할당 0으로 프레임 그래프가 평평하게 유지되는 것을 비교한다. 탄막·파티클처럼 생성·파괴가 잦은 오브젝트를 다룰 때 쓴다.

프롬프트

포탑이 0.12초마다 수명 0.95초 총알을 쏘는 장면을 두 레인으로 비교해줘: ① new Bullet() — 28칸 힙에 live(노랑)/garbage(회색) 블록이 쌓이다 가득 차면 mark&sweep 스윕 바가 지나가며 게임이 0.28초 HITCH로 멈추고 프레임 그래프에 62ms 스파이크 ② 32슬롯 Object Pool — on/off 슬롯과 free-list head 표시, 할당 0, 프레임 16ms 평평. Unity ObjectPool<T> 기준으로 만들어줘.

라이브 데모 열기 — 오브젝트 풀 vs GC 스파이크

프레임 선형 할당자

Per-frame linear (bump) allocator vs fragmenting general heap

  • C++
  • Unreal
  • Unity

프레임 동안 쓰는 임시 데이터(경로, 문자열, 컬링 리스트)를 포인터 덧셈만으로 할당하고 프레임 끝에 offset=0으로 한 번에 비우는 선형 할당자와, malloc/free 반복으로 단편화되는 일반 힙을 비교한다. 임시 메모리 전략을 설계할 때 쓴다.

프롬프트

64KB 선형 할당자 막대에 path·strings·cull list·events·sort keys 블록이 프레임 1.25초 주기로 차례로 쌓이며 offset 화살표가 이동하고, 프레임 끝에 "offset = 0" 초록 플래시로 일괄 해제되게 해줘. 아래에는 2~8KB 블록이 무작위로 free 되어 총 여유는 충분한데 최대 연속 블록이 12KB 미만이라 alloc(12KB) 실패가 뜨는 단편화 힙을 함께 보여줘.

라이브 데모 열기 — 프레임 선형 할당자

세대 카운터 핸들 (댕글링 참조 방지)

Generational handles vs raw indices (stale reference / ABA)

  • C++
  • Rust
  • Unreal

유도 미사일이 노리던 적이 죽고 같은 슬롯에 아군이 새로 들어오면 원시 인덱스는 아군을 추적하지만, {인덱스, 세대} 핸들은 세대 불일치로 무효 처리되는 차이를 보여 준다. 엔티티·리소스 참조를 안전하게 보관할 때 쓴다.

프롬프트

유도 미사일이 slot 3 적을 추적하다 1.7초에 적이 폭발해 슬롯이 해제(gen 1→2)되고 2.4초에 같은 slot 3에 아군이 스폰되는 장면을 두 레인으로 보여줘: raw index 레인은 미사일이 방향을 틀어 아군을 맞추고("아군 피격!"), handle{idx 3, gen 1} 레인은 slots[3].gen(2) ≠ 1이라 null을 받아 직진 후 자폭. 오른쪽에 5칸 슬롯 테이블(점유자·세대)을 하이라이트해줘.

라이브 데모 열기 — 세대 카운터 핸들 (댕글링 참조 방지)

공간 해시 그리드 브로드페이즈

Spatial hash grid broad-phase (hashed uniform grid buckets)

  • Canvas
  • Unity
  • C++

움직이는 46개 오브젝트를 24px 셀에 해시해 버킷에 담고, 각 오브젝트는 주변 3×3 셀만 검사해 전수 비교 1035쌍을 수십 쌍으로 줄이는 과정을 보여 준다. 무한 월드에서 쓸 수 있는 브로드페이즈를 설명할 때 쓴다.

프롬프트

46개 원이 튕겨 다니는 아레나에 24px 균일 그리드를 겹치고, 셀 좌표를 (cx·73856093 XOR cy·19349663) % 10 해시로 10개 버킷에 넣어 오른쪽 버킷 리스트에 점으로 표시해줘. 플레이어(노란 원)가 주변 3×3 셀만 질의하며 후보 연결선을 긋고, 프레임마다 brute n(n−1)/2 = 1035쌍 vs 그리드 검사 쌍 수와 감소율을 표시해줘.

라이브 데모 열기 — 공간 해시 그리드 브로드페이즈

스윕 앤 프룬 (정렬 끝점)

Sweep and prune with insertion-sorted interval endpoints

  • C++
  • Box2D
  • Canvas

AABB를 x축에 투영한 시작·끝점을 정렬 리스트로 유지하고, 매 프레임 거의 정렬된 상태를 삽입 정렬 몇 번의 스왑으로 갱신해 겹치는 후보 쌍만 뽑는 과정을 보여 준다. 시간적 일관성을 활용한 브로드페이즈를 설명할 때 쓴다.

프롬프트

좌우로 움직이는 8개 AABB를 x축에 투영한 구간과 b0/e0… 끝점 칩 16개의 정렬 리스트를 그려줘. 순서가 바뀔 때 칩이 25%씩 보간되며 자리를 바꾸고 그 프레임의 삽입 정렬 swap 수를 표시하며, x 겹침 후보 쌍 목록에서 y까지 겹치는 쌍만 HIT로 강조해 28쌍 중 몇 쌍만 정밀 검사하는지 보여줘.

라이브 데모 열기 — 스윕 앤 프룬 (정렬 끝점)

분리축 정리 (SAT) 투영

Separating Axis Theorem with edge-normal projection intervals

  • Canvas
  • Unity
  • C++

오각형과 사각형의 모든 변 법선 9개를 후보 축으로 삼아 두 도형을 투영한 구간을 차례로 비교하고, 틈이 있는 축이 하나라도 있으면 충돌 없음, 전부 겹치면 최소 겹침 축으로 MTV를 구하는 과정을 보여 준다. 볼록 다각형 충돌 판정을 구현할 때 쓴다.

프롬프트

회전하는 오각형 A와 원형 궤도로 지나가는 사각형 B에 대해 변 법선 9개 축을 0.4초마다 하나씩 하이라이트하며, 축 직선 위에 A(하늘색)·B(분홍) 투영 구간과 겹친 구간(흰색), 꼭짓점→투영 점선을 그려줘. 오른쪽 리스트에 축별 겹침 길이 막대(틈이면 gap 초록)를 실시간 갱신하고, 모든 축이 겹치면 최소 겹침 축 방향 MTV 화살표를 표시해줘.

라이브 데모 열기 — 분리축 정리 (SAT) 투영

GJK 심플렉스 진화

GJK collision test: simplex evolution on the Minkowski difference

  • C++
  • Box2D
  • Canvas

두 볼록 도형의 민코프스키 차(A−B)를 실제로 만들지 않고 support 함수로 점·선·삼각형 심플렉스를 키워 원점을 감싸는지 판정하는 GJK를 단계별로 보여 준다. 임의의 볼록 형상 충돌을 구현할 때 쓴다.

프롬프트

왼쪽에 육각형 A와 삼각형 B, 오른쪽에 A−B 민코프스키 차 볼록 껍질(모든 꼭짓점 차 점 포함)과 원점을 그리고, support(d) = supA(d) − supB(−d)로 심플렉스를 0.7초마다 한 단계씩 확장해줘. 방향 d 화살표, 새 support 점 글로, 원점 반대쪽 점 제거 X 표시를 보여주고 4.5초씩 분리 케이스(support·d < 0 조기 종료)와 충돌 케이스(삼각형이 원점 포함)를 번갈아 재생해줘.

라이브 데모 열기 — GJK 심플렉스 진화

EPA 관통 깊이 확장

Expanding Polytope Algorithm (EPA) for penetration depth & MTV

  • C++
  • Box2D
  • Canvas

GJK가 끝난 삼각형에서 원점에 가장 가까운 변을 찾고 그 법선 방향 support 점을 끼워 넣기를 반복해, 겹친 두 도형의 관통 깊이와 밀어낼 방향을 구하는 과정을 보여 준다. 충돌 응답용 MTV를 계산할 때 쓴다.

프롬프트

10각형 A와 사각형 B가 겹친 상태에서 GJK 종료 삼각형으로 시작해, 0.75초마다 원점에 가장 가까운 변(흰색 굵게)과 그 법선 화살표, 새 support 점(글로)을 보여주며 다각형을 확장해줘. support 거리 − 변 거리 < 0.05면 수렴해 깊이를 표시하고, 왼쪽 월드에서 B를 MTV만큼 0.6초 easeInOut으로 밀어내 분리시키는 결과까지 그려줘.

라이브 데모 열기 — EPA 관통 깊이 확장

연속 충돌 검출 (터널링 방지)

Continuous collision detection: tunneling vs swept test with time of impact

  • Box2D
  • Unity
  • Canvas

프레임당 86px 이동하는 탄환이 5px 벽을 이산 검사에서는 그냥 통과(터널링)하고, 이동 구간을 쓸어 검사하면 충돌 시각 t(TOI)에서 멈추는 차이를 스트로보 프레임으로 비교한다. 빠른 탄환·작은 오브젝트 충돌을 다룰 때 쓴다.

프롬프트

0.38초 간격 스트로보로 탄환의 프레임별 위치(f0~f8)를 찍어 두 레인을 비교해줘: ① 이산 겹침 검사 — Δ 86px > 벽 5px + 2r이라 어느 프레임에도 겹치지 않아 "터널링!" ② 스윕 검사 — 벽을 반지름 r만큼 두껍게(민코프스키) 만든 슬랩과 p(t)=p0+tΔ의 교차 t = (wall−r−p0)/Δ를 계산해 TOI 지점에서 멈추며 스파크. 오른쪽에 수식 패널을 붙여줘.

라이브 데모 열기 — 연속 충돌 검출 (터널링 방지)

적분기 비교: 에너지 드리프트

Numerical integrators: explicit Euler vs semi-implicit vs Verlet vs RK4

  • C++
  • Unity
  • Canvas

같은 스프링(ω = π, dt = 0.05s)을 네 적분기로 돌려 위상 공간 궤적과 에너지 그래프를 비교해, 명시적 오일러는 에너지가 폭주하고 반암시적 오일러·Verlet은 유계 진동, RK4는 거의 보존되는 차이를 보여 준다. 게임 물리 적분기를 고를 때 쓴다.

프롬프트

질량-스프링(a = −ω²x, ω = π, x0 = 1)을 dt = 0.05s로 Explicit Euler, Semi-implicit Euler, Velocity Verlet, RK4 네 칸에 동시에 돌려줘. 칸마다 스프링에 매달린 상자, 위상 공간(x, v/ω) 궤적과 정답 원(점선), E/E₀ 수치를 그리고, 하단에 네 에너지 곡선을 겹친 그래프(1.0 기준선)를 실시간으로 그려 오일러가 8초 만에 몇 배로 폭주하는 것을 보여줘.

라이브 데모 열기 — 적분기 비교: 에너지 드리프트

순차 임펄스 반복 횟수와 웜 스타트

Sequential impulse solver: iteration count & warm starting on a box stack

  • Box2D
  • PhysX
  • C++

상자 6개를 쌓을 때 접촉 솔버 반복 1·4·10회와 1회+웜 스타트를 나란히 돌려, 반복이 적으면 임펄스가 위아래로 덜 전달되어 상자가 서로 파고드는 관통량을 비교한다. 물리 엔진 솔버 설정과 스택 안정성을 설명할 때 쓴다.

프롬프트

높이 13px 상자 6개를 살짝 띄워 떨어뜨리고, 누적 임펄스를 0 이상으로 클램프하는 순차 임펄스 솔버(Baumgarte β = 0.2, slop 0.1px, g = 600px/s²)를 반복 1·4·10회, 1회 + 웜 스타트(이전 프레임 임펄스 재적용) 네 칸에서 동시에 돌려줘. 접촉마다 관통량을 빨간 띠로, 하단에 총 관통 px(약 13·3·1.4·0px)를 표시해 Erin Catto식 웜 스타트 효과를 보여줘.

라이브 데모 열기 — 순차 임펄스 반복 횟수와 웜 스타트

타일 충돌 축 분리 해결

Tile collision: per-tile MTV snagging vs axis-separated resolution

  • Canvas
  • Phaser
  • Godot

평평한 타일 바닥을 가속하며 달릴 때 타일마다 최소 겹침 축으로 동시에 밀어내면 이음매에서 x로 밀려 멈추고(걸림), X 이동→해결 후 Y 이동→해결로 나누면 매끄럽게 지나가는 차이를 보여 준다. 2D 타일맵 캐릭터 충돌을 구현할 때 쓴다.

프롬프트

16px 타일 바닥 위에서 가속도 240px/s², 최대 40px/s, 중력 2400px/s²로 오른쪽으로 달리는 10×24 캐릭터를 두 레인으로 비교해줘: ① 모든 겹친 타일에 대해 ox<oy면 x, 아니면 y로 동시에 밀어내기 — 이음매에서 ox가 oy보다 작아 계속 x로 밀려 "솔기에 걸림!"(고스트가 점프로 빠져나와도 다음 이음매에서 또 걸림) ② x 이동 후 x 충돌 해결, y 이동 후 y 충돌 해결 — 끝의 벽까지 매끄럽게 진행. 겹친 타일을 x(빨강)/y(노랑) 띠로 디버그 표시해줘.

라이브 데모 열기 — 타일 충돌 축 분리 해결

옵저버 패턴 (서브젝트 알림)

Observer pattern: subject notifying decoupled systems

  • Unity
  • C#
  • Godot

적이 죽을 때 전투 코드는 EnemyDied 한 번만 알리고 업적·오디오·킬 카운터 UI·퀘스트가 각자 구독해 반응하며, 완료된 퀘스트는 구독을 해지하는 흐름을 보여 준다. 게임플레이 코드와 부가 시스템을 분리할 때 쓴다.

프롬프트

0.85초마다 슬라임을 처치하면 Subject.notify(EnemyDied)에서 Achievement(7킬 업적), AudioSystem, KillCounterUI, QuestTracker(슬라임 4/4) 네 옵저버로 베지어 선을 따라 펄스가 0.35초 easeInOut으로 날아가 각 박스가 반응하게 해줘. 퀘스트는 4킬 달성 후 unsubscribe되어 선이 점선·회색으로 바뀌고 이후 알림을 받지 않으며, 하단에 observers[] 배열과 동기 호출 코드를 표시해줘.

라이브 데모 열기 — 옵저버 패턴 (서브젝트 알림)

이벤트 큐 링 버퍼 (요청 병합)

Event queue ring buffer with duplicate-request aggregation

  • C++
  • Unity
  • FMOD

연쇄 폭발이 한 프레임에 같은 효과음을 여러 번 요청해도 8칸 원형 큐에서 대기 중인 같은 소리는 볼륨 최댓값으로 병합되고, 오디오 스레드는 head에서 자기 속도로 꺼내 재생하는 구조를 보여 준다. 송신과 처리 시점을 분리할 때 쓴다.

프롬프트

배럴 7개가 연쇄 폭발하며 play(BOOM/GLASS/COIN/SCREAM, volume) 요청을 보내면 8칸 링 버퍼의 tail에 쓰이고, 이미 대기 중인 같은 ID는 새 칸 없이 max(volume)으로 병합(흰 테두리 플래시)되게 해줘. 오디오 쪽은 0.42초마다 head에서 하나씩 꺼내 스피커 파동으로 재생하고, head/tail 화살표, pending 개수, (tail+1)%8 != head 오버플로 가드 설명을 함께 그려줘.

라이브 데모 열기 — 이벤트 큐 링 버퍼 (요청 병합)

커맨드 패턴 · 유닛 명령 큐

Command pattern: input mapped to queued command objects (RTS shift-queue)

  • Unity
  • C#
  • Unreal

우클릭·Shift+우클릭·A+클릭·B+클릭 입력이 각각 Move·Attack·Build 커맨드 객체가 되어 유닛의 명령 큐에 쌓이고, 앞에서부터 execute()·isDone()으로 하나씩 처리되는 RTS 예약 명령을 보여 준다. 입력과 행동을 분리해 AI·리플레이·재바인딩을 쉽게 할 때 쓴다.

프롬프트

RTS 맵에서 커서가 우클릭(Move), Shift+우클릭(Move), A+클릭(Attack 타워), B+클릭(Build) 순으로 0.5초 간격 입력하면 오른쪽 unit.commandQueue에 Command 카드가 슬라이드 인으로 쌓이고, 유닛이 머리부터 execute() 하며 진행 막대가 차고 끝나면 done→pop 되게 해줘. 맵에는 번호 웨이포인트와 남은 경로 점선, 타워 HP 감소와 건물이 올라가는 모습을 보여줘.

라이브 데모 열기 — 커맨드 패턴 · 유닛 명령 큐

업데이트 순서와 1프레임 지연

Component update order dependency (camera one-frame lag)

  • Unity
  • Godot
  • Unreal

카메라가 플레이어보다 먼저 업데이트되면 지난 프레임 위치를 따라가 대시 순간 캐릭터와 HP 바가 화면에서 흔들리고, 플레이어→카메라(LateUpdate) 순서면 고정되는 차이를 보여 준다. 시스템 간 의존 순서와 실행 순서 설정을 설명할 때 쓴다.

프롬프트

평소 70px/s, 2초마다 0.35초 동안 최대 590px/s로 대시하는 캐릭터를 카메라가 따라가는 횡스크롤을 두 레인으로 비교해줘: ① Update 순서 Camera→Player→HPBar — 카메라가 1프레임 전 위치를 써서 화면 오프셋 v·dt(최대 약 10px, 표시는 ×3)가 생기고 HP 바도 어긋남 ② Player→Camera(LateUpdate)→HPBar — 오프셋 0. 레인마다 순서 칩, 오프셋 수치와 스파크라인을 표시해줘.

라이브 데모 열기 — 업데이트 순서와 1프레임 지연

더블 버퍼 (스캔 순서 오염 방지)

Double buffer: in-place update corruption vs read-current/write-next swap

  • C++
  • Unity
  • Canvas

불이 4방향 이웃으로 번지는 15×10 격자를 제자리(in-place)로 갱신하면 이미 갱신된 칸을 읽어 한 틱에 오른쪽·아래로 폭주하고, 현재 버퍼를 읽어 다음 버퍼에 쓰고 교체하면 대칭으로 한 칸씩 번지는 차이를 보여 준다. 셀룰러 오토마타·동시 상태 갱신을 구현할 때 쓴다.

프롬프트

15×10 잔디 격자 중앙에 불씨를 두고 "불 붙은 4이웃이 있으면 점화" 규칙을 1.1초 틱마다 행 우선 스캔(흰 커서가 0.8초 동안 훑음)으로 적용해, 왼쪽 in-place 격자는 스캔 중 읽은 새 값 때문에 →↓ 방향으로 한 틱에 길게 번지고, 오른쪽 double buffer 격자는 back 버퍼에 쓴 칸을 초록 테두리로 표시했다가 SWAP 태그와 함께 마름모꼴로 한 칸씩 번지게 해줘.

라이브 데모 열기 — 더블 버퍼 (스캔 순서 오염 방지)

더티 플래그 (씬 그래프 변환)

Dirty flag for scene-graph world transforms (deferred recompute)

  • Unity
  • Godot
  • C++

배→돛대 망루→해적→앵무새 계층에서 로컬 변환이 바뀔 때마다 즉시 월드 변환을 다시 계산하면 한 프레임에 10번, 더티 플래그로 렌더 직전에 한 번씩 계산하면 4번이면 되는 차이를 보여 준다. 계층 변환·파생 데이터 캐싱을 설계할 때 쓴다.

프롬프트

파도에 흔들리는 배, 망루, 해적, 앵무새를 부모-자식 계층으로 그리고, 한 프레임(3.6초 슬로모션) 동안 ship/nest/pirate/parrot.setLocal()이 0.4초 간격으로 호출될 때마다 오른쪽 씬 그래프 노드에 빨간 dirty 깃발이 서게 해줘. 하단 카운터는 즉시 갱신이 4+3+2+1 = 10칸, render() 순회에서 깃발을 지우며 계산하는 더티 플래그 방식은 4칸만 채워지도록 비교해줘.

라이브 데모 열기 — 더티 플래그 (씬 그래프 변환)

서비스 로케이터와 널 서비스

Service locator with null object and logging decorator providers

  • Unity
  • C#
  • C++

게임 코드는 Locator.audio().play()만 호출하고, 부팅·테스트에는 아무것도 안 하는 NullAudio, 게임 중엔 RealAudio, 디버그엔 로그를 남기는 LoggedAudio 데코레이터가 소켓에 꽂혀 교체되는 구조를 보여 준다. 전역 서비스 접근과 테스트 대체를 설계할 때 쓴다.

프롬프트

점프·코인 획득 때 Locator.audio().play("jump"/"coin")을 호출하는 미니 게임 옆에 Locator 소켓을 그리고, 2.5초마다 NullAudio(∅ no-op) → RealAudio(스피커 파동) → LoggedAudio(Real)(파동 + "[audio] play(...) t=..." 로그 줄 슬라이드 인) 모듈이 0.5초 easeOut으로 꽂혀 교체되게 해줘. 하단에 Locator.provide() 코드와 BOOT/GAME/DEBUG 단계 태그를 표시해줘.

라이브 데모 열기 — 서비스 로케이터와 널 서비스

플라이웨이트 숲 (공유 모델 + 인스턴스)

Flyweight: shared tree model with per-instance extrinsic state

  • Unity
  • Three.js
  • C++

나무 1,000그루가 메시·텍스처(576KB)를 하나의 TreeModel로 공유하고 위치·크기·색조·흔들림 위상(32B)만 각자 가지면 563MB가 0.6MB로 줄고 인스턴싱으로 드로우 콜 1번이 되는 것을 보여 준다. 대량의 반복 오브젝트를 렌더링·저장할 때 쓴다.

프롬프트

숲에 나무가 0→1,000그루로 심어지며(화면엔 90그루, 크기·색조·흔들림 위상만 다름) 오른쪽에 공유 TreeModel(mesh 64KB + bark 256KB + leaf 256KB = 576KB ×1)과 인스턴스 데이터(pos/scale/tint/phase = 32B × n) 카드, 몇 그루에서 모델로 이어지는 점선을 그려줘. 하단 메모리 막대에서 naive는 256MB 예산선을 넘어 OUT OF MEMORY, flyweight는 0.6MB·1 instanced draw call로 유지되게 해줘.

라이브 데모 열기 — 플라이웨이트 숲 (공유 모델 + 인스턴스)

타입 오브젝트 (데이터 정의 종족)

Type Object pattern: data-defined breeds with parent inheritance

  • Unity
  • C#
  • JSON

몬스터 종류를 클래스 상속 대신 breeds.json의 데이터(부모 종족에서 기본값 상속)로 정의하고, 새 종족 TrollKing을 입력해 저장하면 코드 수정 없이 바로 스폰되는 것을 보여 준다. 디자이너가 콘텐츠 종류를 늘리는 데이터 주도 구조를 만들 때 쓴다.

프롬프트

breeds.json 카드(Troll hp48 atk7, TrollArcher parent Troll ranged, TrollWizard parent Troll hp30 fire)와 오른쪽 몬스터 아레나를 그리고, 3.6초에 "TrollKing": {"parent":"Troll","hp":120,"scale":1.6}이 타자기처럼 1.2초간 입력된 뒤 저장되면 왕관 쓴 1.6배 몬스터가 0.5초 easeOut으로 스폰되게 해줘. 몬스터에서 자기 breed로 이어지는 점선과 "breed → 이름", parent 체인 copy-down 설명을 넣어줘.

라이브 데모 열기 — 타입 오브젝트 (데이터 정의 종족)

바이트코드 스택 VM

Bytecode virtual machine: stack-based spell interpreter

  • C++
  • Lua
  • C#

마법 setHealth(0, getHealth(0) + (getAgility(0) + getWisdom(0)) / 2)가 LITERAL·GET_*·ADD·DIVIDE·SET_HEALTH 12개 명령으로 컴파일되어 PC가 한 줄씩 내려가며 스택에 값이 쌓이고 계산되는 과정을 보여 준다. 모딩·스크립트용 안전한 인터프리터를 만들 때 쓴다.

프롬프트

Robert Nystrom의 Bytecode 예제처럼 LITERAL 0, LITERAL 0, GET_HEALTH, LITERAL 0, GET_AGILITY, LITERAL 0, GET_WISDOM, ADD, LITERAL 2, DIVIDE, ADD, SET_HEALTH를 0.42초 간격으로 실행하며 PC 하이라이트, 스택 [0]→[0,45]→[0,45,7,11]→[0,45,18]→[0,45,9]→[0,54]→[] 블록이 easeOut으로 쌓이고 빠지게 해줘. 마지막에 마법사의 HP 바가 45→54로 차오르며 +9 HP 파티클이 뜨게 해줘.

라이브 데모 열기 — 바이트코드 스택 VM

코루틴 시퀀스 (yield 재개 지점)

Coroutine-driven scripted sequence with yield resume points

  • Unity
  • C#
  • Godot

성문 열기→1초 대기→경비 이동(도착까지 매 프레임 조건 폴링)→대사→한 프레임 대기→주인공 입장을 하나의 코루틴으로 쓰고, 각 yield에서 멈췄다 다음 프레임 루프에서 재개되는 지점을 타임라인으로 보여 준다. 컷신·튜토리얼 같은 시간 순서 로직을 작성할 때 쓴다.

프롬프트

Unity 코루틴 IEnumerator OpenGate()의 gate.Open(); yield return new WaitForSeconds(1f); guard.WalkTo(); yield return new WaitUntil(() => guard.arrived); guard.Say("통과!"); yield return null; hero.Enter(); 를 현재 줄 하이라이트와 함께 실행하고, 위쪽 게임 화면에서 성문이 0.6초에 열리고 경비가 1.6초 걸어가 말풍선을 띄운 뒤 주인공이 1.5초 easeInOut으로 들어오게 해줘. 오른쪽 타임라인에 Wait 1s·WaitUntil 구간, 매 프레임 폴링 틱, MoveNext 재개 점을 표시해줘.

라이브 데모 열기 — 코루틴 시퀀스 (yield 재개 지점)

에셋 스트리밍 링과 IO 큐

Distance-ring asset streaming with prioritized IO queue, LOD rings & memory budget

  • Unreal
  • Unity
  • C++

플레이어 주변 로드 반경(2.6청크)에 들어온 청크를 거리순 IO 큐로 하나씩 읽어 들이고, LOD0·LOD1·LOD2 링으로 디테일을 나누며, 메모리 예산을 넘으면 언로드 반경(3.6청크) 밖 청크부터 내보내는 오픈월드 스트리밍을 보여 준다. 끊김 없는 대규모 월드 로딩을 설계할 때 쓴다.

프롬프트

12×9 청크 월드를 플레이어가 돌아다니는 탑다운 뷰에 load(2.6)·unload(3.6, 점선 히스테리시스)·LOD0(1.3)·LOD1(2.3) 링을 그리고, 청크 상태를 미로드/대기(주황 점선)/로딩(하늘색 진행 바, 청크당 0.14초)/상주(L0~L2 명암)로 표시해줘. 오른쪽에 거리 우선 IO 큐 목록과 24칸 메모리 예산 그리드를 두고, 예산이 차면 unload 링 밖 청크를 evict 태그와 함께 해제해줘.

라이브 데모 열기 — 에셋 스트리밍 링과 IO 큐

비동기 씬 로딩 파이프라인

Async scene loading: fade, background load, activation hitch & fade-in

  • Unity
  • Unreal
  • Godot

문에 들어가면 0.3초 페이드아웃→로딩 화면에서 백그라운드 로드(progress 0.9까지)→최소 표시 시간 대기→Awake/Start 활성화 히치→이전 씬 언로드·GC→0.4초 페이드인으로 이어지는 레벨 전환 단계를 프레임 시간 그래프와 함께 보여 준다. 레벨 전환 로딩 흐름을 설계할 때 쓴다.

프롬프트

Unity SceneManager.LoadSceneAsync(allowSceneActivation=false) 흐름으로 캐릭터가 문에 들어가 0.3초 페이드아웃, 회전 점 스피너와 0→0.9로 차는 진행 바(2초 easeOut), 0.9에서 "최소 표시 시간 대기", 활성화(Awake/Start) 순간 메인 스레드 58ms 히치, 이전 씬 언로드+GC, 0.4초 페이드인 후 새 레벨이 나오게 해줘. 오른쪽 단계 리스트 하이라이트와 하단 프레임 시간 막대(16.7ms 기준선)를 함께 그려줘.

라이브 데모 열기 — 비동기 씬 로딩 파이프라인

세이브 파일 버전 마이그레이션

Save-game serialization with versioned migration chain

  • Unity
  • C#
  • JSON

v1 세이브 파일을 v3 게임이 읽을 때 version 필드를 보고 v1→v2(hp→health 이름 변경), v2→v3(pos 배열→{x,y}, stamina 기본값 추가) 마이그레이터를 순서대로 적용한 뒤 CRC를 확인하고 로드하는 과정을 보여 준다. 업데이트 후에도 예전 세이브가 깨지지 않게 할 때 쓴다.

프롬프트

save_slot1.json 카드에 {"version":1,"hp":80,"pos":[12,4],"gold":250}을 띄우고, 오른쪽 마이그레이션 체인 v1→v2(rename hp→health), v2→v3(pos→{"x":12,"y":4}, + "stamina":100)이 1.8초 간격으로 활성화될 때마다 JSON 줄이 변경(~ 주황)·추가(+ 초록) 하이라이트로 0.6초 동안 바뀌게 해줘. crc32 표시가 갱신되고, 마지막에 게임 화면에 캐릭터가 health 80/stamina 100(신규) 바와 함께 로드되게 해줘.

라이브 데모 열기 — 세이브 파일 버전 마이그레이션

입력 컨텍스트 스택

Input action contexts: stacked action maps with consume, pass-through & blocking

  • Unity Input System
  • Unreal Enhanced Input
  • Godot

Gameplay 위에 차에 타면 Vehicle, 지도를 열면 blocking MapUI 컨텍스트가 쌓이고, 키 입력은 맨 위부터 검사해 바인딩이 있으면 소비·없으면 아래로 전달·blocking이면 차단되는 라우팅을 보여 준다. 탈것·UI·대화처럼 상황별 조작 체계를 설계할 때 쓴다.

프롬프트

키 입력 W, E, W, M, W, E, Esc, E, W가 0.8초 간격으로 들어오면 오른쪽 컨텍스트 스택(Gameplay → +Vehicle → +MapUI(blocking))을 위에서 아래로 내려가는 경로선으로 따라가 consumed/pass/blocking 결과를 팝업해줘. E로 차에 타면 Vehicle push, Vehicle에 없는 M은 Gameplay까지 통과해 지도를 열고(MapUI push), 지도 열린 동안 E는 차단, Esc로 pop, E로 하차해 pop 되는 흐름을 왼쪽 게임 화면과 함께 Unity Input System 액션맵 개념으로 보여줘.

라이브 데모 열기 — 입력 컨텍스트 스택

핫 리로드 (상태 유지 반영)

Hot reload with preserved runtime state vs full restart

  • Unity
  • Unreal Live Coding
  • Godot

플레이 중 player.json의 jumpHeight를 3.0→4.5로 바꾸면 핫 리로드는 0.45초 만에 위치·코인을 유지한 채 점프가 높아지고, 전체 재시작은 컴파일·부팅 3초 후 처음 위치로 돌아가는 차이를 비교한다. 반복 튜닝 속도를 높이는 개발 파이프라인을 설명할 때 쓴다.

프롬프트

오른쪽으로 달리며 점프하고 코인을 먹는 캐릭터 두 레인 위에 1.4초 시점 "player.json jumpHeight: 3.0 → 4.5" 편집 토스트를 띄워줘: ① HOT RELOAD — 파일 감지 0.25초 + 리로드 0.2초 후 같은 위치에서 점프 높이 점선이 18→30px로 바뀜 ② FULL RESTART — 컴파일 1.6초 + 부팅 1.4초 진행 바 후 pos x와 코인이 초기화. 레인마다 편집→반영 시간 타임라인과 state 유지/손실 패널을 그려줘.

라이브 데모 열기 — 핫 리로드 (상태 유지 반영)

데이터 주도 밸런싱 (시트 → 스탯)

Data-driven design: spreadsheet → CSV → importer → unit stats

  • Unity
  • Google Sheets
  • CSV

기획 시트의 유닛 행(HP·속도·공격력)이 CSV→임포터→UnitData 에셋으로 흘러 게임 유닛을 정의하고, 시트에서 Archer 속도 1.0을 1.8로 고치면 코드 수정 없이 재임포트되어 바로 빨라지는 것을 보여 준다. 밸런스 수치를 코드 밖으로 빼는 구조를 설명할 때 쓴다.

프롬프트

units.xlsx 표(Knight 120/1.0/14, Archer 70/1.0/9, Mage 55/0.8/22, Golem 260/0.5/30)와 Sheet → CSV → Importer → UnitData 파이프라인 칩, 오른쪽에 유닛 4종이 각자 speed×18px/s로 걷는 레인을 그려줘. 3초에 Archer 속도 셀이 주황 테두리로 편집되어 1.8이 되면 빛 패킷이 1.2초 동안 파이프라인을 지나고 Archer가 즉시 1.8배로 빨라지며 "live 반영" 태그가 뜨게 해줘(HP 바는 hp/260).

라이브 데모 열기 — 데이터 주도 밸런싱 (시트 → 스탯)

로컬라이제이션 문자열 테이블

Localization string tables: keys, ICU plurals, text expansion & fallback

  • Unity Localization
  • ICU
  • i18next

메뉴 버튼이 키(menu.start 등)로 문자열 테이블을 조회해 한국어→영어→독일어→일본어로 바뀌며, 독일어 길이 증가로 넘친 버튼은 자동 맞춤되고, 복수형 규칙과 누락 키의 영어 폴백이 어떻게 처리되는지 보여 준다. 다국어 게임 UI를 설계할 때 쓴다.

프롬프트

게임 타이틀 메뉴(게임 시작/설정/종료, 폭 56px 버튼)와 strings.csv 표(key × ko/en/de/ja)를 나란히 두고 2초마다 언어를 바꿔 현재 열을 하이라이트해줘. de의 "Einstellungen"이 넘치면 빨간 overflow 후 0.6초에 auto-fit 폰트 축소(%)로 맞추고, ja에 없는 menu.quit은 en "Quit"으로 폴백하며 주황 테두리, hud.items는 n=1→3에 따라 "1 item/3 items", "1 Gegenstand/3 Gegenstände" ICU 복수형으로 바뀌게 해줘.

라이브 데모 열기 — 로컬라이제이션 문자열 테이블

상태 패턴 vs 거대한 switch 문

State pattern (enter / update / exit objects) vs a sprawling switch statement

  • Unity
  • C#
  • Godot

캐릭터 상태를 enum과 switch로 처리하면 새 상태 하나에 update·onInput·animate 곳곳을 고쳐야 하지만, 상태마다 enter·update·exit를 가진 객체로 나누면 새 클래스 하나만 추가하면 되는 차이를 보여 준다. 상태가 늘어나는 플레이어·보스 코드를 정리할 때 쓴다.

프롬프트

플랫포머 캐릭터가 Idle→Run(62px/s)→Jump(정점 22px, 0.45s)→Fall→Idle을 자동으로 반복하다 3.4초에 Dash(170px/s, 0.45s) 상태 추가 요청이 오게 해줘. 왼쪽 switch 코드는 enum, update(), onInput(), animate() 네 곳에 +case DASH 줄이 0.3초 간격으로 초록 diff로 끼어들며 '수정 4곳' 태그가 오르고, 오른쪽 State 객체 패널은 DashState 카드 하나만 슬라이드 인하며 전이 때마다 이전 상태 exit()·새 상태 enter() 칩이 0.35초 점등되고 화살표가 그려지게 해줘.

라이브 데모 열기 — 상태 패턴 vs 거대한 switch 문

상속 계층 vs 컴포넌트 조합

Deep inheritance hierarchy (diamond problem, base-class bloat) vs component composition

  • Unity
  • Unreal
  • C++

날아다니는 적·고정 포탑·탑승 탱크 같은 요구가 들어올 때 상속 트리는 코드 복붙, 불필요한 메서드 상속, 다이아몬드 상속, 베이스 클래스 비대화로 꼬이지만, 엔티티×컴포넌트 표에서는 점 몇 개를 찍는 조합으로 끝나는 차이를 보여 준다. 게임 오브젝트 구조를 설계할 때 쓴다.

프롬프트

2.9초 간격으로 요청 3개(날아다니는 적, 이동 없는 포탑, 플레이어가 타는 탱크)를 띄우고, 왼쪽 상속 트리(GameObject→Character/Vehicle→Player/Enemy/Tank)에 새 노드가 붙을 때마다 'Fly() 복붙', 'Move() 빈 오버라이드', 빨간 점선 다이아몬드 경고가 나오며 GameObject 메서드 막대가 4→9칸으로 차오르게 해줘. 오른쪽은 6엔티티×7컴포넌트(Trans·Health·Move·Input·AI·Shoot·Fly) 매트릭스에 새 행의 점이 70ms 스태거 backOut으로 찍히고, 아래 미리보기에 날개·포신·바퀴가 조합된 캐릭터를 그려줘.

라이브 데모 열기 — 상속 계층 vs 컴포넌트 조합

메시지 버스 · 토픽 구독 (와일드카드)

Message bus with hierarchical topics, wildcard subscriptions and deferred dispatch

  • Unity
  • C#
  • C++

전투·인벤토리·퀘스트가 서로를 참조하지 않고 combat.enemy.died 같은 토픽으로 버스에 발행하면, UI·오디오·업적·분석이 inventory.#, combat.*, *.enemy.died 같은 패턴으로 구독해 프레임 끝에 일괄 배달받는 구조를 보여 준다. 시스템 간 결합을 N×M에서 N+M으로 줄일 때 쓴다.

프롬프트

발행자 3개(Combat·Inventory·Quest)가 0.65초마다 토픽 메시지 캡슐을 내려보내 버스를 따라 가운데 MessageBus로 모이고, 프레임 끝 dispatch 후 0.3초 easeInOut으로 패턴이 맞는 구독자에게만 갈라져 날아가게 해줘. 구독자는 HUD(inventory.#, quest.#), Audio(combat.* — combat.enemy.died는 안 맞음), Achievement(*.enemy.died, *.boss.died), Analytics(#)로 두고 맞은 패턴 칩을 점등, 수신 카운터를 올리며, 하단에 토픽 로그 #seq와 '직접 참조 3×4=12 vs 버스 3+4=7' 비교를 표시해줘.

라이브 데모 열기 — 메시지 버스 · 토픽 구독 (와일드카드)

씬 그래프 순회 · 재부모화

Scene graph pre-order traversal, world-matrix propagation & reparenting (keep world vs keep local)

  • Unity
  • Godot
  • Three.js

탱크→포탑→포신→총구처럼 중첩된 계층을 부모 먼저(전위) 순회하며 world = parent.world × local을 누적하는 과정과, 상자를 총구 밑으로 옮길 때 월드 변환을 유지하는지 로컬 값을 유지하는지에 따른 차이를 보여 준다. 계층 구조와 붙였다 떼는 오브젝트를 다룰 때 쓴다.

프롬프트

흔들리는 포탑(±0.36rad)과 굴러가는 바퀴를 가진 2D 탱크와 Hierarchy 패널(Root·Tank·WheelL·WheelR·Turret·Barrel·Muzzle·Crate)을 그리고, 0.32초마다 전위 순회 커서가 한 행씩 내려가며 해당 노드에 x/y 축 기즈모를 띄우고 하단에 W(Barrel) = L(Root)·L(Tank)·L(Turret)·L(Barrel)과 월드 좌표·회전을 표시해줘. 4.6초에 Crate를 Muzzle 자식으로 옮기며 keepWorld(L' = W(Muzzle)⁻¹·W(Crate), 제자리 유지 후 함께 회전)와 keepLocal(빨간 점선 고스트가 순간이동)을 동시에 보여 줘.

라이브 데모 열기 — 씬 그래프 순회 · 재부모화

리소스 참조 카운팅 · 순환 누수

Shared resource reference counting, unload on zero, and cyclic-reference leaks fixed with weak refs

  • C++
  • Unreal
  • Unity

여러 오브젝트가 같은 텍스처·메시·사운드를 공유할 때 참조 수가 0이 되는 순간 언로드되고, 머티리얼끼리 강한 참조로 서로를 붙잡으면 오브젝트가 다 사라져도 카운트가 1에 멈춰 메모리가 새며, 한쪽을 weak 참조로 바꾸면 연쇄 해제되는 과정을 보여 준다. 에셋 캐시와 핸들 수명을 설계할 때 쓴다.

프롬프트

오브젝트 4개(Rock·Tree·Player·Lake)가 0.25초 간격으로 생성되며 rock.png(4MB, Rock·Tree 공유), tree.mesh, step.wav, water.mat↔foam.mat에 곡선 링크를 펄스로 연결하고 오른쪽 캐시 박스의 refcount 배지가 오르내리다 0이 되면 'unload' 팝과 함께 흐려지게 해줘. 앞 4.5초는 water↔foam 강한 순환이라 13MB에서 멈추며 LEAK 경고, 뒤 4.5초는 foam→water를 weak 점선으로 바꿔 0.3초 뒤 연쇄 해제되게 하고, 하단에 resident MB 그래프와 shared_ptr / weak_ptr 코드를 표시해줘.

라이브 데모 열기 — 리소스 참조 카운팅 · 순환 누수

스레드 간 큐 · 뮤텍스 vs 락프리 링

Inter-thread producer/consumer queue: mutex contention vs lock-free SPSC ring buffer

  • C++
  • Unreal
  • Rust

게임 스레드가 오디오 스레드로 명령을 보낼 때 뮤텍스로 감싼 큐는 서로 락을 기다리고, 락을 쥔 채 OS에 선점되면 상대가 통째로 멈추지만, 단일 생산자·단일 소비자 링 버퍼는 atomic head/tail만으로 대기 없이 주고받는 차이를 보여 준다. 렌더·오디오·IO 스레드 통신을 설계할 때 쓴다.

프롬프트

두 레인에서 같은 작업 패턴(2~4틱 작업)을 42틱/초로 흘려 Game(생산자)·Audio(소비자) 간트 차트 64틱 창을 스크롤하고, 뮤텍스 레인은 임계 구역 2틱(주황)·락 대기(빨강)와 자물쇠 소유자 색, 96·236틱에 '락 쥔 채 OS 선점 → 13틱 정지' 경고를 띄워줘. 락프리 레인은 16칸 원형 버퍼에 tail(생산자만 씀)·head(소비자만 씀) 화살표와 채워진 칸을 그리고, 두 레인 모두 전송 수·대기 %·12틱당 처리량 스파크라인을 표시해줘.

라이브 데모 열기 — 스레드 간 큐 · 뮤텍스 vs 락프리 링

결정론 · 부동소수점 연산 순서

Cross-platform determinism: float32 operation order & FMA divergence vs fixed-point, with checksum lanes

  • C++
  • Unity DOTS
  • Canvas

같은 입력의 시뮬레이션도 플랫폼마다 곱셈·덧셈을 따로 반올림하느냐 FMA로 한 번에 반올림하느냐에 따라 마지막 비트가 달라지고, 충돌이 많은 혼돈계에서는 이 차이가 5초 만에 화면에 보이는 분기로 커지며, 정수 고정소수점은 끝까지 일치하는 것을 보여 준다. 락스텝·리플레이용 시뮬레이션을 만들 때 쓴다.

프롬프트

20개 원형 기둥이 있는 188×128 당구판에서 같은 초기값(20.5, 25.25, v=83.1/51.7px/s)의 공을 float32 개별 반올림(x64)과 FMA식 단일 반올림(ARM) 두 방식으로 60Hz 540틱 동안 돌려 청록·분홍 궤적을 겹쳐 그리고, Q8 고정소수점 공은 초록 링으로 그려줘. 오른쪽에 틱별 상태 해시 4레인(최근 20틱 일치=초록, 불일치=빨강)과 '첫 비트 차이 tick', '1px 이상 tick', (0.1+0.2)+0.3 ≠ 0.1+(0.2+0.3) 실제 값을 표시하고, 하단에 |A−B| 로그 그래프(1e-7~1e3px, 1px 기준선)를 그려줘.

라이브 데모 열기 — 결정론 · 부동소수점 연산 순서

난수 스트림 분리 · 시드 트리

Separate RNG streams per system derived from a seed tree (cosmetic randomness must not desync gameplay)

  • Unity
  • C++
  • Canvas

난수 생성기 하나를 모두가 나눠 쓰면 파티클 옵션만 바꿔도 이펙트가 난수를 더 소비해 같은 시드에서 드랍 결과가 달라지지만, hash(seed, "gameplay")처럼 시스템별 스트림을 나누면 꾸밈용 난수가 게임플레이 시퀀스를 건드리지 않는 것을 보여 준다. 리플레이·락스텝·데일리 시드 모드를 만들 때 쓴다.

프롬프트

seed 42로 0.55초마다 이벤트 12개를 처리하며, 위 패널은 공용 mulberry32 하나에서 A(파티클 낮음, vfx 1회)와 B(파티클 높음, vfx 3회)가 난수 테이프(vfx 청록·gameplay 주황 칸, 2자리 값)를 소비하고 드랍 보석(<15 희귀, <45 고급)이 어긋나는 칸에 빨간 테두리와 '불일치 n/12'를 띄워줘. 아래 패널은 gameplay 스트림을 분리해 A·B 결과가 12/12 일치하게 하고, 오른쪽에 seed 42 → gameplay(loot, crit)·vfx(particles, shake)·ai 트리와 각 노드의 FNV-1a 해시를 표시하며 소비될 때 해당 노드를 점등해줘.

라이브 데모 열기 — 난수 스트림 분리 · 시드 트리

타이머 휠 · 게임 시간 vs 실제 시간

Timer wheel scheduler with pause-aware scaled game time vs unscaled real time

  • Unity
  • Unreal
  • C++

지연 콜백을 16칸 타이머 휠 슬롯에 넣고 바늘이 지나갈 때 실행하되, 독 틱·버프 종료 같은 게임 타이머는 일시정지와 슬로모션을 따르고 UI 깜박임·자동 저장·핑 같은 실제 시간 타이머는 계속 흐르는 차이를 보여 준다. 쿨다운·버프·재시도 타이머를 관리할 때 쓴다.

프롬프트

250ms/슬롯 16칸 휠 두 개(game-time, real-time)를 그리고 0~2.5초 timeScale 1, 2.5~4초 일시정지(0), 4~5.5초 슬로모션 0.5, 이후 1로 진행해줘. 게임 휠에는 독 틱(1초 반복)·적 리스폰(3.6s)·버프 종료(4.5s), 실제 휠에는 UI 깜박임(1.5s 반복)·핑(2.6s)·자동 저장(5.6s)을 점으로 꽂고 바퀴 수만큼 안쪽 링에 배치, 바늘이 닿으면 글로와 이름 팝으로 실행하며, 가운데에 game/real 시계와 g(t) 그래프, 하단에 '[game 3.00s @ real 5.00s]' 실행 로그를 표시해줘.

라이브 데모 열기 — 타이머 휠 · 게임 시간 vs 실제 시간

모듈 의존성 · 로드 순서 · 순환 검출

Engine module dependency graph: topological load order, lazy loading, reverse shutdown & cycle detection

  • Unreal
  • C++
  • Godot

Core·Memory·RHI·Renderer·Gameplay 같은 엔진 모듈을 의존 그래프의 위상 정렬 순서로 초기화하고, 에디터처럼 무거운 모듈은 처음 쓸 때 지연 로드하며, 종료는 역순으로 하고, 잘못 추가된 의존이 순환을 만들면 DFS로 찾아 시작을 거부하는 과정을 보여 준다. 플러그인·모듈 구조를 설계할 때 쓴다.

프롬프트

모듈 11개를 의존 깊이별 열로 배치하고 진입 차수 배지를 단 뒤 Kahn 알고리즘으로 0.3초마다 큐에서 하나씩 꺼내 초록으로 로드하며 오른쪽에 로드 순서와 대기 큐를 쌓아줘. 3.75초에 점선 Editor 모듈을 '첫 사용'으로 지연 로드, 4.7초부터 0.13초 간격 역순 Shutdown() 목록, 6.5초에 Renderer→Gameplay 빨간 의존을 추가해 DFS가 Gameplay→UI→Renderer를 gray로 칠하다 gray 재방문(back edge)에서 '순환 의존 감지'와 경로를 출력하게 해줘.

라이브 데모 열기 — 모듈 의존성 · 로드 순서 · 순환 검출

콘솔 변수 · 설정 우선순위 계층

Console variables with layered config priority (default → platform → user → command line → console) and change callbacks

  • Unreal
  • C++
  • Unity

같은 CVar 값이 기본값·플랫폼 ini·유저 설정·명령줄·런타임 콘솔에서 덮어써질 때 적용 순서가 아니라 우선순위가 높은 계층이 이기고, 값이 바뀌면 OnChanged 콜백이 섀도맵 재할당 같은 처리를 하는 구조를 보여 준다. 그래픽 옵션·디버그 스위치·플랫폼별 설정을 관리할 때 쓴다.

프롬프트

r.ShadowQuality·r.ScreenPercentage·t.MaxFPS·au.MasterVolume·net.TickRate 5행 × Default·Platform·User·CmdLine·Console 5열 표를 만들고 Default(0.3s)→Platform(0.9s)→CmdLine(1.5s)→User(2.1s) 순으로 열을 적용해 이긴 칸은 계층색 박스, 진 칸은 취소선으로 그려줘. 늦게 적용된 User의 ScreenPercentage 85가 CmdLine 50에 막혀 '우선순위 낮음 · 무시'로 튕기게 하고, 콘솔에 r.ShadowQuality 0(4.5s)과 net.TickRate 20(6.6s)을 타이핑해 resolved 열이 backOut으로 바뀌며 OnChanged 로그, 미리보기의 그림자·해상도(50% 픽셀화)·fps 캡이 즉시 반영되게 해줘.

라이브 데모 열기 — 콘솔 변수 · 설정 우선순위 계층

크래시 핸들링 · 미니덤프 · 심볼화

Crash handling pipeline: exception → out-of-process minidump → upload → symbolication, with breadcrumbs

  • C++
  • Unreal
  • Sentry

게임이 널 포인터로 죽는 순간 예외 핸들러가 별도 크래시 프로세스로 미니덤프를 쓰고, 백그라운드로 업로드한 뒤 서버에서 PDB·dSYM으로 주소를 함수명과 줄 번호로 바꾸고, 직전 행동을 남긴 breadcrumb 로그와 함께 기존 이슈에 묶는 흐름을 보여 준다. 출시 빌드의 크래시 수집을 설계할 때 쓴다.

프롬프트

게임 뷰에서 파이어볼을 쏘는 동안 0.4초마다 breadcrumb(level.load, spawn, ui.open, equip, ability.cast…)이 8칸 링 버퍼에 쌓이다 3.25초에 ACCESS_VIOLATION read 0x00000018로 화면이 붉은 글리치와 함께 멈추게 해줘. 오른쪽 파이프라인 5단계(예외 0.35s → 핸들러 0.45s → 미니덤프 0.9s, 1.8MB·24 threads → 업로드 1.4s, 1.3MB/s → 심볼화 1.2s)를 진행 막대로 채우고, 콜스택 5줄이 0x7FF6… raw 주소에서 AbilityFireball::Apply() fireball.cpp:142로 0.18초 스태거 크로스페이드된 뒤 'sig 9F3A·C1 → 기존 이슈에 병합' 태그를 띄워줘.

라이브 데모 열기 — 크래시 핸들링 · 미니덤프 · 심볼화

플랫폼별 메모리 예산

Per-platform, per-category memory budgets (texture, mesh, audio, anim, heap) vs actual usage

  • Unreal
  • Unity
  • C++

플레이어가 마을→숲→보스로 진행하는 동안 PC·콘솔·휴대기·모바일마다 텍스처·메시·오디오·애니메이션·힙 사용량을 카테고리 예산과 비교해, 어느 플랫폼의 어느 카테고리가 언제 넘치는지 경고로 잡아내는 메모리 예산 관리를 보여 준다. 멀티플랫폼 출시 전 메모리 목표를 정하고 지킬 때 쓴다.

프롬프트

상단 진행 바에서 마을→숲→보스를 7초에 걸쳐 easeInOut으로 이동하며, 플랫폼 4열(PC 6.5GB, 콘솔 5.5GB, 휴대기 2.1GB, 모바일 1.45GB 예산)에 카테고리 5색 스택 막대와 카테고리별 예산 눈금을 그리고 넘친 카테고리는 빨간 테두리로 깜박이게 해줘. 오른쪽 표는 2.1초마다 플랫폼을 바꿔 '사용/예산 MB'와 100% 흰 선을 넘는 막대(%)를 보여 주고, 아래에 '[휴대기] Audio 104% @보스' 같은 첫 초과 경고를 최근 3줄 쌓아줘.

라이브 데모 열기 — 플랫폼별 메모리 예산

문자열 인터닝 · 해시 이름 ID

String interning with hashed name IDs (FName / StringId): O(1) compares, bucket chaining & memory savings

  • Unreal
  • C++
  • Godot

"Enemy.Goblin" 같은 이름을 한 번만 이름 테이블에 저장하고 FNV-1a 해시로 찾은 정수 ID를 들고 다니면, 문자열 비교는 정수 한 번 비교가 되고 같은 이름은 같은 ID를 돌려받으며 메모리도 크게 줄어드는 구조를 보여 준다. 태그·애니메이션 이름·이벤트 키를 자주 비교하는 엔진 코드에 쓴다.

프롬프트

0.74초마다 Weapon.Sword, Enemy.Goblin, Fx.Spark, Enemy.Golem, Ui.Close, Enemy.Goblin(중복), Sfx.Hit, Weapon.Bow, Weapon.Sword(중복)을 인터닝하며 글자 타이핑 → fnv1a 해시 굴림 → & 7 버킷 표시 후 8버킷 체이닝 테이블에 'id + 문자열' 칩이 슬라이드 인하고, 중복이면 기존 칩이 초록으로 점등되며 '이미 있음 → id n'이 뜨게 해줘(버킷 5 충돌 체인 포함). 왼쪽에 Enemy.Goblin vs Enemy.Golem strcmp가 12자/초로 9회 비교하는 동안 id 비교는 1회로 끝나는 장면과, 오브젝트 10,000개 기준 std::string 48B(469KB) vs FName 4B(39KB) 막대를 표시해줘.

라이브 데모 열기 — 문자열 인터닝 · 해시 이름 ID

리플렉션 · 자동 인스펙터 · 직렬화

Reflection metadata driving auto-generated inspector UI and serialization (UPROPERTY-style)

  • Unreal
  • Unity
  • C++

클래스에 UPROPERTY 같은 표시를 단 필드는 코드 생성기가 이름·타입·오프셋·플래그 메타데이터를 만들고, 에디터 인스펙터와 저장 파일이 그 메타데이터만 보고 자동으로 만들어져 필드를 한 줄 추가하면 UI와 JSON에 바로 나타나고 Transient 필드는 빠지는 구조를 보여 준다. 에디터 도구와 저장 시스템을 코드 수정 없이 확장할 때 쓴다.

프롬프트

Enemy.h 코드 패널에 Health·Level·Tint·AggroTimer(Transient) 필드를 두고 0.7~2.3초에 'UPROPERTY(EditAnywhere) float MoveSpeed = 4.5;'를 타이핑, UHT 코드 생성 진행 태그 뒤 3.2초 메타데이터 표(name·type·offset +0x2B0·flags), 3.5초 Details 패널 슬라이더, 3.8초 JSON 키가 차례로 초록 하이라이트로 나타나게 해줘. 이후 커서가 Health를 120→60, MoveSpeed를 4.5→9로 드래그하고 Tint를 분홍→청록으로 바꾸면 미리보기 적의 크기·걷는 속도·색과 JSON 값이 실시간으로 바뀌고, AggroTimer는 인스펙터·JSON 모두에서 제외되게 해줘.

라이브 데모 열기 — 리플렉션 · 자동 인스펙터 · 직렬화

게임 루프 구조 비교 (단일 · 렌더 스레드 · 태스크 그래프)

Game loop architectures compared: single-threaded vs dedicated render thread vs task-graph job loop

  • Unreal
  • Unity
  • C++

같은 프레임 작업(Input 1ms, Update 6ms, Physics 5ms, Anim 4ms, Render 9ms, GPU 12ms)을 한 스레드에 직렬로 두는 루프, 렌더 제출을 별도 스레드로 빼는 루프, 워커 4개에 잡으로 쪼개는 태스크 그래프 루프의 프레임 시간·코어 사용·병목 위치를 나란히 비교한다. 엔진 스레딩 구조를 고를 때 쓴다.

프롬프트

세 레인에 간트 타임라인을 14ms/초 속도로 스크롤해줘: 단일 스레드는 Main 한 줄에 25ms 직렬(40fps), 렌더 스레드는 Game 16ms와 Render 9ms(이전 프레임)가 겹쳐 16ms(62fps), 태스크 그래프는 W0~W3에 Update 2ms×3, Physics 2.5ms×2, Anim 1ms×4, Render 3ms×3을 분산해 CPU 8.5ms지만 GPU 12ms에 묶여 83fps 'GPU 병목'이 되게 해줘. 블록은 작업 종류별 색(Input·Update·Physics·Anim·Render·GPU)에 프레임 번호, 프레임 경계 세로선, 왼쪽에 ms·fps·지연·코어 사용과 완료 프레임 카운터를 표시해줘.

라이브 데모 열기 — 게임 루프 구조 비교 (단일 · 렌더 스레드 · 태스크 그래프)