따알깍PROMPT DICT 앱으로 열기

게임 개발 · 제작 · 출시 · 라이브 · 네트워크 · 소셜

멀티플레이 · 네트워크 동기화 Multiplayer netcode & synchronization

클라이언트 예측, 서버 재조정, 엔티티 보간, 랙 보상, 롤백, 락스텝, 델타 압축처럼 지연·지터·패킷 손실을 숨기는 멀티플레이 넷코드 기법. 클라이언트 | 서버 분할 화면, 날아가는 패킷, 틱 마커와 RTT HUD로 원리를 그대로 보여 준다.

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

카드 목록 65개
  1. 권위 서버 & 덤 클라이언트
  2. 클라이언트 사이드 예측
  3. 서버 재조정 (미확인 입력 재생)
  4. 엔티티 보간 (100ms 과거 렌더)
  5. 데드 레커닝 + 투사 속도 블렌딩
  6. 랙 보상 (서버 히트박스 되감기)
  7. 샷 비하인드 커버 (사수 우선)
  8. 롤백 넷코드 (GGPO 예측·재시뮬)
  9. 딜레이 기반 vs 롤백 비교
  10. 결정론적 락스텝 (RTS 턴 스케줄링)
  11. 체크섬 동기화 이탈 감지
  12. 상태 동기화 + 시각 오차 스무딩
  13. 델타 압축 (ack된 기준 스냅샷)
  14. 부동소수 양자화 (비트 예산)
  15. 우선순위 누산기 (패킷 예산)
  16. 관심 영역 (그리드 관련성 필터)
  17. 틱레이트 비교 (20 / 64 / 128 Hz)
  18. 지터 버퍼 (재생 지연 vs 언더런)
  19. 서버 입력 버퍼 & 클라이언트 시간 팽창
  20. 입력 중복 전송 (최근 N개 입력)
  21. UDP 신뢰성 ACK 비트필드
  22. 클럭 동기화 (NTP식 오프셋 추정)
  23. 프레임 어드밴티지 & 입력 지연 프레임
  24. 호스트 마이그레이션
  25. P2P 메시 vs 클라이언트-서버
  26. NAT 홀 펀칭 핸드셰이크
  27. Elo 레이팅 업데이트
  28. Glicko 레이팅 편차 (RD)
  29. TrueSkill μ/σ 베이지안 갱신
  30. 서버 이동 검증 (스피드핵 탐지)
  31. MMO 존 핸드오프 (공간 샤딩)
  32. 물리 권한 이전 (소유권 전환)
  33. 네트워크 LOD (거리별 업데이트 빈도)
  34. 예측 발사체 생성 & 서버 확정
  35. 피커스 어드밴티지
  36. 혼잡 회피 (30↔10 pps 모드 전환)
  37. 패킷 분할·재조립 (MTU)
  38. 릴레이 서버 폴백 (TURN)
  39. 지역 서버 선택 · 핑 측정 · 확장
  40. 패킷 손실 시각화 · 랜덤 vs 버스트
  41. 대역폭 예산 · 플레이어 수 · 틱
  42. 스냅샷 동기 vs 이벤트 동기
  43. 신뢰 · 비신뢰 RPC 채널 선택
  44. 히트 판정 검증 · 서버 허용 오차
  45. 입력 지연 숨기기 · 로컬 연출 선행
  46. 지연 보상 상한 (리와인드 캡)
  47. 클라이언트 신뢰 경계 매트릭스
  48. 매칭 품질 · 핑 vs 실력 창
  49. 보이스 챗 지터 버퍼 · PLC
  50. 재접속 · 상태 복원
  51. 게임 백엔드 서비스 흐름 · 재시도
  52. 웹소켓 vs WebRTC 데이터 채널
  53. 네트워크 컨디셔너 프로파일 테스트
  54. 비트 패킹 · Varint & ZigZag
  55. 넷 도먼시 (휴면 액터 복제 생략)
  56. 진행 중 매치 백필
  57. RTT 추정 · SRTT · RTTVAR · RTO
  58. 커넥트 토큰 · 챌린지 핸드셰이크
  59. 토큰 버킷 RPC 레이트 리밋
  60. 서브틱 입력 타임스탬프
  61. 랙 스위치 탐지 · 명령 시간 예산
  62. 각도 보간 래핑 (최단 호)
  63. 서버 틱 예산 · 과부하 대응
  64. 롤백 재시뮬 CPU 예산
  65. 연결 품질 HUD · 히스테리시스

권위 서버 & 덤 클라이언트

Authoritative server with dumb client (inputs up, state down)

  • Canvas
  • Node.js
  • Unity

클라이언트는 키 입력만 보내고 서버가 모든 이동을 시뮬레이션·검증해 상태를 돌려주는 기본 구조로, 치트가 원천 차단되는 대신 입력이 화면에 반영되기까지 RTT만큼 늦어지는 이유를 보여 준다.

프롬프트

Canvas 2D로 CLIENT A / SERVER 두 레인을 만들고 클라이언트는 10Hz로 ◀▶ 입력 패킷만, 서버는 10Hz로 x 상태 패킷만 보내게 해줘(편도 150ms, 58px/s). 클라이언트 아바타는 서버 상태로만 움직여 누른 순간(점선 고스트)보다 300ms 늦게 따라가고, 중간에 클라이언트가 보낸 'x+=80' 순간이동 요청은 서버가 최대 속도 검증으로 REJECT 하게 하며, 입력→화면 지연 바를 HUD로 보여줘.

라이브 데모 열기 — 권위 서버 & 덤 클라이언트

클라이언트 사이드 예측

Client-side prediction (local simulation of own input)

  • Canvas
  • Unity
  • Unreal

자기 캐릭터는 서버 응답을 기다리지 않고 입력 즉시 로컬에서 같은 이동 규칙으로 시뮬레이션해 RTT만큼의 반응 지연을 없애는 기법으로, 서버가 결정론적으로 같은 결과를 낼 때 쓴다.

프롬프트

같은 입력 타임라인(빠른 좌우 탭 포함)을 두 클라이언트 레인에 넣어 OFF는 RTT 240ms 뒤에야 움직이고 ON은 입력 즉시 62px/s로 움직이게 비교해줘. ON 레인에는 마지막으로 받은 서버 상태를 점선 앰버 고스트로 240ms 뒤따르게 그리고, 레인마다 잔상 12개와 input→screen 0ms / 240ms 수치, 키 변경 순간 '즉시!' / '+240ms 뒤' 팝업을 띄워줘.

라이브 데모 열기 — 클라이언트 사이드 예측

서버 재조정 (미확인 입력 재생)

Server reconciliation (replay unacknowledged inputs)

  • Canvas
  • Unity
  • Godot

서버 상태가 과거 입력 기준으로 도착해도 그 위에 아직 확인되지 않은 입력들을 다시 적용해 예측 위치를 유지하는 기법으로, 예측을 켠 뒤 생기는 러버밴딩을 없앨 때 쓴다.

프롬프트

입력마다 시퀀스 번호를 붙여 10Hz로 보내고(1입력=7px) 서버 응답에는 마지막 처리 번호 ack를 담아 RTT 330ms 뒤 도착하게 해줘. NAIVE 레인은 응답 위치로 덮어써 3입력(21px) 뒤로 튀는 러버밴딩을, RECONCILE 레인은 서버 위치 + 미확인 입력 재생(화살표 체브론 ×n)으로 매끄러운 이동을 보여 주고, 하단 컨베이어에 #번호 입력 박스가 ack되면 초록 ✓로 바뀌며 버퍼에서 빠지게 해줘.

라이브 데모 열기 — 서버 재조정 (미확인 입력 재생)

엔티티 보간 (100ms 과거 렌더)

Entity interpolation (render remote entities 100 ms in the past)

  • Canvas
  • Source Engine
  • Unity

원격 플레이어를 최신 스냅샷이 아니라 100ms 과거 시점으로 두 스냅샷 사이를 보간해 그려, 낮은 업데이트율과 패킷 손실에도 끊김 없이 움직이게 하는 표준 기법이다.

프롬프트

서버가 20Hz(50ms)로 스냅샷을 보내고 지연 40–70ms, 손실 9%를 넣은 뒤 render_t = now − latency − 100ms로 버퍼에서 앞뒤 스냅샷 A,B를 찾아 α=(render_t−tA)/(tB−tA)로 선형 보간해줘. 경로 위에 받은 스냅샷은 앰버 다이아몬드, 손실은 빨간 X, 보간 구간은 시안 선으로 표시하고 보간 결과·최신 스냅샷만 쓴 계단식 고스트·실제 서버 위치를 함께 그리며, 하단 타임라인에 now/render 커서와 α 값을 실시간 표시해줘.

라이브 데모 열기 — 엔티티 보간 (100ms 과거 렌더)

데드 레커닝 + 투사 속도 블렌딩

Dead reckoning with projective velocity blending (vs snap correction)

  • Canvas
  • Unity
  • Unreal

드문드문 오는 위치·속도 업데이트 사이를 p+v·Δt로 외삽하고, 새 업데이트가 오면 순간이동 대신 현재 표시 상태와 새 투사 경로를 블렌딩해 차량·비행체가 튀지 않게 하는 기법이다.

프롬프트

원격 차량이 2.5Hz(400ms)로 위치·속도를 보내고 지연 100ms로 도착하게 한 뒤, 표시 위치를 송신 시각 기준 p+v·(t−t_s)로 1차 외삽해줘. SNAP(빨강)은 업데이트 때 새 투사로 바로 점프하고, PVB(초록)는 블렌드 350ms 동안 v_b=lerp(v_표시, v_new, k), P_t=P_0+v_b·τ, P_t'=p_new+v_new·τ, 결과=lerp(P_t, P_t', k)로 섞게 해줘. 도로 위에 업데이트 링·외삽 점선·두 궤적과 실제 위치 고스트, 오차 px HUD를 그려줘.

라이브 데모 열기 — 데드 레커닝 + 투사 속도 블렌딩

랙 보상 (서버 히트박스 되감기)

Lag compensation (server-side hitbox rewind)

  • Canvas
  • Source Engine
  • Unreal

서버가 플레이어별 히트박스 기록을 1초 보관하다가 사격 명령이 오면 쏜 사람이 보던 시점(지연+보간)으로 되감아 판정해, 지연이 있어도 조준한 대로 맞게 해 주는 FPS 표준 기법이다.

프롬프트

SHOOTER VIEW / SERVER 두 패널로 만들고 사수는 상대를 ping 100ms + interp 100ms 과거로 보게 해줘(대상 속도 45px/s). 서버 패널에는 50ms 간격 히트박스 히스토리를 점선으로 남기고, 명령 도착 시 현재 히트박스로 판정하면 MISS, 300ms(=RTT 200 + interp 100) 되감은 박스로 판정하면 HIT가 되는 과정을 easeInOutCubic 되감기 애니메이션으로 보여 주며, 하단 타임라인에 client view / fire / cmd arrives와 rewind 구간을 표시해줘.

라이브 데모 열기 — 랙 보상 (서버 히트박스 되감기)

샷 비하인드 커버 (사수 우선)

Favor-the-shooter trade-off: killed behind cover

  • Canvas
  • Source Engine
  • Unity

랙 보상 때문에 피격자는 자기 화면에서 이미 벽 뒤로 숨은 뒤에 죽는 현상을 사수 화면과 피격자 화면으로 나란히 보여 주며, 사수 우선 판정의 대가와 되감기 상한의 필요성을 설명한다.

프롬프트

탑다운 맵 두 패널(SHOOTER 화면 / VICTIM 화면)에 같은 벽과 사수, 25px/s로 벽 뒤로 달리는 피격자를 그리고, 사수 화면은 피격자를 latency 50ms + interp 100ms 과거로 그려 아직 노출된 순간 발사하게 해줘. 서버가 되감아 HIT 판정 → 50ms 뒤 피격자 화면에서는 이미 엄폐한 지 약 150ms 후에 '엄폐 뒤에서 사망'이 뜨게 하고, 시야선(초록 실선/빨강 점선), 엄폐 시간 태그, 하단 이벤트 타임라인, 0.5배 슬로모션과 rewind cap 200ms 캡션을 넣어줘.

라이브 데모 열기 — 샷 비하인드 커버 (사수 우선)

롤백 넷코드 (GGPO 예측·재시뮬)

Rollback netcode (GGPO: predict remote input, roll back & resimulate)

  • Canvas
  • GGPO
  • C++

상대 입력이 도착하지 않은 프레임은 마지막 입력을 반복한다고 예측해 바로 진행하고, 실제 입력이 다르면 저장해 둔 상태로 되감아 그 사이 프레임을 한 틱 안에 재시뮬레이션하는 격투 게임 넷코드다.

프롬프트

대전 격투 두 캐릭터와 프레임 스트립(local / remote 입력 행)을 만들고 원격 입력이 4프레임(≈67ms, ping 133ms) 늦게 도착하게 해줘. 확정 전 원격 칸은 점선 예측 칸(마지막 입력 반복)으로, 도착한 입력이 예측과 다르면 빨간 곡선 화살표로 f−4까지 되감고 4프레임을 앰버로 순차 재시뮬하며 잘못 예측된 포즈를 빨간 점선 고스트로 0.45초 페이드시켜줘. 매 프레임 상태 저장·로드를 전제로 0.2배 슬로모션 표기를 넣어줘.

라이브 데모 열기 — 롤백 넷코드 (GGPO 예측·재시뮬)

딜레이 기반 vs 롤백 비교

Delay-based vs rollback netcode under a latency spike

  • Canvas
  • GGPO
  • Unity

같은 지연 스파이크에서 딜레이 기반 넷코드는 상대 입력을 기다리느라 게임이 멈추고, 롤백은 멈추지 않고 예측한 뒤 몇 프레임을 보정하는 차이를 나란히 보여 준다.

프롬프트

위 레인은 입력 지연 3f(50ms) 딜레이 기반으로 편도 지연이 50ms를 넘으면 게임 시간을 멈춰 'WAITING FOR INPUT…'과 누적 지연(game time −ms)을 표시하고, 아래 레인은 입력 지연 1f 롤백으로 상대를 마지막 입력으로 외삽하며 rollback n f 바와 실제 위치 고스트를 그려줘. 하단에는 35ms 기반 + 165ms·135ms 두 번의 지연 스파이크 그래프, 50ms 예산선, 정지 구간 빨간 음영, now 커서를 넣어줘.

라이브 데모 열기 — 딜레이 기반 vs 롤백 비교

결정론적 락스텝 (RTS 턴 스케줄링)

Deterministic lockstep with scheduled command turns (RTS)

  • Canvas
  • C++
  • Unity

유닛 상태 대신 명령만 주고받고 모든 피어가 같은 턴에 같은 명령을 실행해 수백 유닛을 적은 대역폭으로 동기화하는 RTS 방식으로, 한 명의 입력이 늦으면 모두가 기다린다.

프롬프트

턴 200ms, 입력 지연 2턴으로 P1·P2 두 화면에 같은 탑다운 RTS 맵과 5기 편대 2개를 그려줘. 명령은 발행 턴 n에 '@T(n+2)' 마커로 예약되어 상대 화면에는 120ms 뒤 나타나고 두 화면에서 정확히 같은 턴에 동시에 출발하게 하며, 아무 명령이 없어도 턴마다 no-op을 보내는 하단 턴 타임라인(P1/P2 슬롯)을 만들고, P2 입력이 600ms 늦는 구간에는 두 화면 모두 'WAITING FOR P2'로 멈춰줘.

라이브 데모 열기 — 결정론적 락스텝 (RTS 턴 스케줄링)

체크섬 동기화 이탈 감지

Checksum desync detection (per-tick state hash)

  • Canvas
  • C++
  • JavaScript

락스텝·롤백처럼 결정론에 기대는 게임에서 피어들이 주기적으로 상태 해시를 교환해, 눈에 보이지 않는 1e-4 수준의 부동소수 차이도 즉시 DESYNC로 잡아내는 디버깅·보안 장치다.

프롬프트

9개 공이 탄성 충돌하는 같은 시뮬을 PEER A/B 패널에서 30틱/s로 돌리고, B만 60틱에 공 하나의 x에 1e-4를 더해줘. 매 틱 위치를 1e6 배 정수화해 FNV-1a 32비트 해시를 만들고 10틱마다 교환해 로그 행(tick, A 해시, B 해시, ✓/✗)을 쌓으며, 불일치 순간 'DESYNC @ tick 60' 경고와 빨간 테두리를 띄운 뒤 카오스로 점점 커지는 위치 차(A 고스트·연결선, max Δ px)를 보여줘.

라이브 데모 열기 — 체크섬 동기화 이탈 감지

상태 동기화 + 시각 오차 스무딩

State synchronization with visual error smoothing

  • Canvas
  • Unity
  • PhysX

양쪽이 모두 물리를 돌리면서 주기적으로 받은 상태로 물리값은 즉시 스냅하되, 화면에는 이전 렌더 위치와의 오차 오프셋을 매 프레임 줄여 가며 더해 튐 없이 수렴시키는 기법이다.

프롬프트

원격 화면에서 공·플레이어 상태를 6Hz(손실 20%)로 받아 물리 상태는 즉시 스냅(앰버 점선 원)하고, 스냅 순간 err = 이전 렌더 위치 − 새 물리 위치로 저장해 렌더 = 물리 + err로 그려줘. err는 매 프레임 |err|≤10px(0.25m)이면 ×0.95, ≥40px(1m)이면 ×0.85, 그 사이는 선형 보간으로 줄이고, 오른쪽 HUD에 |err| px, 현재 감쇠 계수, 2초 |err| 그래프와 스냅 틱을 표시해줘.

라이브 데모 열기 — 상태 동기화 + 시각 오차 스무딩

델타 압축 (ack된 기준 스냅샷)

Delta compression against the last acknowledged snapshot

  • Canvas
  • C++
  • Unity

클라이언트가 확인(ack)한 마지막 스냅샷을 기준으로 바뀐 필드만 보내 스냅샷 크기를 수분의 1로 줄이는 기법으로, ack가 유실되면 기준이 오래돼 델타가 커지는 것까지 보여 준다.

프롬프트

엔티티 8개 × 필드 4개(x, y, rot, hp) 표를 만들고 매 스냅샷(0.32s)마다 일부 필드만 바뀌게 한 뒤, 기준 = ack가 도착한 가장 최근 스냅샷(2틱 뒤 도착, 28% 유실)으로 잡아 기준과 다른 셀만 앰버로 강조해줘. 크기는 헤더 6B + 바뀐 엔티티마다 id·마스크 2B + 필드당 2B로 계산해 풀 스냅샷 76B 점선과 함께 최근 24개 막대 그래프·절감률을 그리고, 하단 ack 스트립에 ✓/✗와 현재 기준 #을 표시해줘.

라이브 데모 열기 — 델타 압축 (ack된 기준 스냅샷)

부동소수 양자화 (비트 예산)

Float quantization & bit budgets (bounded position, smallest-three quaternion)

  • Canvas
  • C++
  • Unreal

범위가 정해진 위치를 n비트 정수 격자로 반올림하고 쿼터니언은 가장 큰 성분을 빼고 3개만 9비트로 보내, 오차를 통제하면서 엔티티당 비트를 크게 줄이는 직렬화 기법이다.

프롬프트

0–16m 위치를 축당 4→5→6→8비트로 2초마다 바꿔 step = 16m/2^b 격자(점 격자, 간격이 2px 미만이면 숨김)에 q = round(p/step)·step으로 스냅하고, 실제 위치(흰 점선)와 양자화 위치(시안), 오차 벡터, ×8 돋보기 인셋, step·err cm 수치를 보여줘. 오른쪽에 float32 xyz 96비트, 양자화 xyz 3b비트, 쿼터니언 128비트 vs smallest-three 2+3×9=29비트를 비트 셀로 그리고 총 절감률을 표시해줘.

라이브 데모 열기 — 부동소수 양자화 (비트 예산)

우선순위 누산기 (패킷 예산)

Priority accumulator with a per-packet budget

  • Canvas
  • C++
  • Unity

객체마다 우선순위를 매 틱 누적하고 큰 순서대로 패킷 예산이 허락하는 만큼만 보낸 뒤 0으로 리셋해, 중요한 객체는 자주 보내면서도 낮은 우선순위 객체가 영원히 굶지 않게 하는 기법이다.

프롬프트

객체 9개(플레이어 ×10, 상호작용 ×3, 이동 ×2, 정지 ×1)를 탑다운 월드와 막대 리스트로 만들고 1초 틱마다 acc += priority 애니메이션(easeOutCubic) → 값 순 정렬 재배치(easeInOutCubic) → 상위 3개를 'budget: top 3' 점선 박스로 묶어 보내고 acc를 0으로 되돌려줘. 막대 옆에 대기 틱 수, 하단에 packet #n → P A B 같은 전송 목록을 표시해 정지 객체도 결국 차례가 오게 해줘.

라이브 데모 열기 — 우선순위 누산기 (패킷 예산)

관심 영역 (그리드 관련성 필터)

Interest management with a spatial relevancy grid (AOI)

  • Canvas
  • Node.js
  • Unreal

서버 월드를 셀 그리드로 나누고 플레이어 주변 3×3 셀 안의 엔티티만 해당 클라이언트에 복제해, 대규모 월드에서도 대역폭과 치트(월핵) 노출을 줄이는 관심 관리 기법이다.

프롬프트

10×6 셀(24px) 서버 월드에 NPC 34개를 원운동시키고 플레이어가 8자 경로로 이동하게 한 뒤, 플레이어 셀 기준 |Δcell|≤1인 3×3 영역을 점선 박스로 하이라이트해 안쪽 NPC만 핑크 토큰+연결선으로 복제하고 바깥은 흐린 점으로 그려줘. 영역에 들어오면 초록 spawn 링, 나가면 빨간 despawn 링을 0.6초 띄우고 replicated n/34와 대역폭 절감 %를 HUD로 보여줘.

라이브 데모 열기 — 관심 영역 (그리드 관련성 필터)

틱레이트 비교 (20 / 64 / 128 Hz)

Server tick rate comparison (20 / 64 / 128 Hz)

  • Canvas
  • Source Engine
  • Unity

같은 좌우 무빙을 서버가 20/64/128Hz로 샘플링할 때 위치가 계단처럼 끊기는 정도와 평균 추가 지연(틱 간격의 절반), 대역폭·CPU 비용을 나란히 비교한다.

프롬프트

0.6초 주기 A-D 무빙(삼각파)을 20Hz·64Hz·128Hz 세 레인에서 floor(t·hz)/hz 시점 값으로 샘플링해, 왼쪽 미니 아레나에는 실제 위치(흰 점선)와 서버 위치, 오른쪽에는 최근 0.45초 실제 곡선 vs 계단식 샘플 그래프와 틱 점을 그려줘. 레인마다 avg +25 / 7.8 / 3.9ms, 현재 위치 오차 px, ×1 / ×3.2 / ×6.4 bw·CPU 바를 표시해줘.

라이브 데모 열기 — 틱레이트 비교 (20 / 64 / 128 Hz)

지터 버퍼 (재생 지연 vs 언더런)

Jitter buffer: playout delay vs underrun

  • Canvas
  • WebRTC
  • C++

일정 간격으로 보낸 패킷이 들쭉날쭉 도착해도 고정 재생 지연만큼 버퍼에 모았다가 일정 속도로 꺼내 쓰는 방식으로, 버퍼가 작으면 언더런으로 끊기고 크면 지연이 늘어나는 트레이드오프를 보여 준다.

프롬프트

30pps로 보낸 패킷에 30–115ms 지연(꼬리 긴 분포) + 7% 확률 +60ms 스파이크를 주고 네트워크 레인에서 서로 추월하며 날아가게 한 뒤, 재생 지연 50ms와 130ms 두 수신자를 만들어 각각 버퍼 슬롯 depth, 재생 시각을 넘긴 늦은 패킷 수(late n/90), 늦으면 멈추는 공 재생(STARVED)을 보여줘. 하단에는 최근 5초 지연 히스토그램과 두 재생 지연 선을 그려줘.

라이브 데모 열기 — 지터 버퍼 (재생 지연 vs 언더런)

서버 입력 버퍼 & 클라이언트 시간 팽창

Server input buffer with client time dilation

  • Canvas
  • C++
  • Unreal

서버가 클라이언트 입력을 2틱 정도 버퍼에 쌓아 두고, 버퍼가 비면 클라이언트에게 시뮬을 조금 빨리, 넘치면 느리게 돌리라고 알려 손실·지터에도 입력이 굶지 않게 하는 커맨드 프레임 동기화 기법이다.

프롬프트

클라이언트가 틱마다 cmd를 보내고 지연 3틱으로 도착해 서버 버퍼(목표 깊이 2, 6칸)에 쌓이게 한 뒤, 7틱 손실 버스트로 버퍼가 비면 STARVED(입력 복제)를 띄우고 client rate = 1 + clamp((2 − depth)·0.035, −0.06, +0.10)로 게이지가 ×1.07까지 올라 버퍼를 다시 채우게 해줘. 패킷이 뭉쳐 도착해 버퍼가 넘치는 구간에는 ×0.97로 느려지게 하고, 하단에 depth·rate 그래프와 기아 틱 마커를 그려줘.

라이브 데모 열기 — 서버 입력 버퍼 & 클라이언트 시간 팽창

입력 중복 전송 (최근 N개 입력)

Redundant input packets (send the last N inputs)

  • Canvas
  • Unity
  • C++

입력 패킷마다 직전 입력 몇 개를 함께 실어 보내 재전송 없이도 손실된 입력을 다음 패킷에서 복구하는 기법으로, 몇 바이트 늘리는 대신 서버의 입력 공백을 없앤다.

프롬프트

N=1과 N=3 두 레인에서 클라이언트가 8pps로 입력 패킷(번호 칸 N개)을 보내고 같은 손실 패턴(22% + 연속 2개 버스트)을 적용해줘. 서버 입력 타임라인 칸은 직접 받으면 시안, 뒤 패킷에서 복구하면 앰버, 재생 시각까지 못 받으면 빨간 '?'로 채우고 레인마다 holes 수와 패킷 크기 4+2N B를 표시해 N=3은 구멍이 0이 되게 해줘.

라이브 데모 열기 — 입력 중복 전송 (최근 N개 입력)

UDP 신뢰성 ACK 비트필드

Reliability over UDP: sequence numbers, ack + 32-bit ack bitfield

  • Canvas
  • C++
  • UDP

모든 패킷 헤더에 시퀀스·마지막 수신 번호(ack)·이전 32개 수신 여부 비트필드를 실어, ack 패킷 일부가 유실돼도 수신 확인이 전달되고 손실된 신뢰성 메시지만 골라 재전송하는 UDP 위 경량 신뢰성 계층이다.

프롬프트

송신자는 4pps로 seq 패킷을 보내고(비행 550ms, 손실 25%) 수신자는 매 패킷에 ack=최신 수신 seq와 비트 n = (ack−n) 수신 여부인 32비트 필드를 담아 돌려보내게 해줘(ack 패킷 손실 15%). 상단 송신 버퍼 칸은 ack되면 초록, ack ≥ seq+3인데 비트가 0이면 손실(빨강)로 바꾸고, 손실된 패킷에 실린 신뢰성 MSG 칩을 다음 송신 패킷에 MSG↻로 다시 실어 보내며, 하단에 32칸 비트필드와 0x 헥사 값을 실시간 표시해줘.

라이브 데모 열기 — UDP 신뢰성 ACK 비트필드

클럭 동기화 (NTP식 오프셋 추정)

Clock synchronization (NTP-style offset & round-trip estimation)

  • Canvas
  • Node.js
  • C#

클라이언트와 서버가 네 개의 타임스탬프 t0~t3를 주고받아 시계 오프셋 θ와 왕복 지연 δ를 구하고, 비대칭 지연의 오차를 줄이려고 δ가 가장 작은 샘플을 고르는 서버 시간 동기화 기법이다.

프롬프트

서버 시계가 +137ms 앞선 상황에서 핑 4회를 시퀀스 다이어그램(server/client 시간축, 상향·하향 패킷 선, t0~t3 라벨)으로 2초씩 애니메이션하고 θ = ((t1−t0)+(t2−t3))/2, δ = (t3−t0)−(t2−t1), 오차 = (d↑−d↓)/2를 계산해 보여줘. 오른쪽 θ vs δ 산점도에 참값 137ms 점선과 샘플 점을 쌓고 최소 δ 샘플에 초록 링을 그려 θ̂와 추정 서버 시각을 표시해줘.

라이브 데모 열기 — 클럭 동기화 (NTP식 오프셋 추정)

프레임 어드밴티지 & 입력 지연 프레임

Frame advantage time sync & input-delay frames (rollback tuning)

  • Canvas
  • GGPO
  • C++

롤백 대전에서 한쪽 피어가 프레임을 앞서 나가면 그쪽만 롤백이 커지므로 앞선 피어가 가끔 1프레임 쉬어 균형을 맞추고, 입력 지연 프레임을 늘리면 롤백 길이와 입력 렉이 맞교환되는 관계를 보여 준다.

프롬프트

피어 A/B의 프레임 테이프(15fps 슬로모)를 만들고 A가 +4프레임 앞서 시작해 어드밴티지 > 0이면 3프레임마다 1프레임 대기(W 칸)로 0에 수렴하게, 64프레임째 B 히치(H 칸) 3프레임 뒤 다시 맞추게 해줘. −4~+4 어드밴티지 게이지와 'A rollback ≤ 3+adv f · B ≤ 3−adv f'를 표시하고, 오른쪽에 편도 3f(ping 100ms)에서 입력 지연 0~4f별 롤백 max(0,3−d)f와 입력 렉 d×16.7ms 막대를 순서대로 하이라이트해줘.

라이브 데모 열기 — 프레임 어드밴티지 & 입력 지연 프레임

호스트 마이그레이션

Host migration (listen-server election & state handoff)

  • Canvas
  • Unity
  • Photon

피어 중 하나가 서버 역할을 하는 리슨 서버 구조에서 호스트가 끊기면 남은 피어가 가장 좋은 연결의 피어를 새 호스트로 뽑고, 마지막 스냅샷을 넘겨받아 게임을 이어 가게 하는 복구 절차다.

프롬프트

오각형으로 배치한 5개 피어(미니 게임 화면 노드)가 P1 호스트와 스타형으로 패킷을 주고받다가 1.8초에 P1이 끊기면(빨간 X, 링크 붕괴) 화면을 멈추고 'HOST MIGRATION' 카운트다운을 띄워줘. 각 피어의 평균 RTT(62/38/71/54ms)를 보여 가장 낮은 P3에게 왕관이 easeInOutCubic 포물선으로 날아가고, 새 링크가 자라며 snapshot #2381을 브로드캐스트한 뒤 5초에 RESUMED로 게임을 재개해줘.

라이브 데모 열기 — 호스트 마이그레이션

P2P 메시 vs 클라이언트-서버

Peer-to-peer mesh vs client-server topology

  • Canvas
  • WebRTC
  • Node.js

플레이어 수 n이 늘 때 P2P 메시는 연결이 n(n−1)/2개로, 피어당 업로드가 (n−1)배로 늘고, 클라이언트-서버는 연결 n개에 클라이언트 업로드가 일정한 대신 서버가 부하와 권위를 맡는 차이를 비교한다.

프롬프트

두 패널에 n=4→6→8을 2.6초마다 바꿔 P2P 메시(모든 쌍 연결)와 클라이언트-서버(중앙 서버 스타)를 easeOutCubic으로 펼치고 모든 링크에 양방향 패킷을 흘려줘. 각 패널에 링크 수(n(n−1)/2 vs n), 플레이어당 업로드(30kbps×(n−1) vs 30kbps), 서버 업로드(30kbps×n) 바를 표시하고 P2P 쪽에는 'no authority · NAT per pair' 경고를 달아줘.

라이브 데모 열기 — P2P 메시 vs 클라이언트-서버

NAT 홀 펀칭 핸드셰이크

NAT punch-through (UDP hole punching via a rendezvous server)

  • Canvas
  • WebRTC
  • UDP

서로 다른 NAT 뒤의 두 피어가 랑데부 서버로 공인 주소를 교환한 뒤 동시에 UDP를 쏘아 각 NAT에 매핑을 만들어 직접 연결을 뚫는 과정을 단계별로 보여 준다.

프롬프트

랑데부 서버, NAT A/B 라우터, 사설 IP 피어 둘을 배치하고 6단계로 애니메이션해줘: 1 register(NAT 매핑 테이블에 :62001⇄:5000 행 추가) → 2 서버가 서로의 공인 주소 전달 → 3 A→B 펀치는 NAT B에서 DROP되지만 NAT A에 B행 생성 → 4 B→A 펀치가 NAT A 통과 → 5 A→B hello 통과 → 6 초록 직통 링크로 양방향 게임 트래픽, 서버는 흐리게. 상단에 STEP n/6 설명, 캡션에 symmetric NAT는 TURN 릴레이로 폴백한다고 적어줘.

라이브 데모 열기 — NAT 홀 펀칭 핸드셰이크

Elo 레이팅 업데이트

Elo rating update (logistic expected score, K-factor)

  • Canvas
  • Node.js
  • Python

두 플레이어의 레이팅 차로 기대 승률 E를 구하고 결과와의 차이에 K를 곱해 점수를 옮기는 Elo 공식을, 예상대로 이긴 경기·이변·동급 경기 세 경우로 시각화한다.

프롬프트

E = 1/(1+10^(−Δ/400)) 로지스틱 곡선(Δ −800~+800) 위에 현재 매치의 Δ 마커를 easeOutCubic으로 이동시켜 E_A를 점선으로 읽어 주고, K=32로 R' = R + K(S−E)를 계산해줘. 1600 vs 1400 승(+7.7), 1400 vs 1600 이변 승(+24.3), 1500 vs 1500 패(−16)를 2.6초씩 보여 주며 플레이어 카드 레이팅을 easeInOutCubic으로 카운트하고 옮겨지는 점수 칩과 계산식을 표시해줘.

라이브 데모 열기 — Elo 레이팅 업데이트

Glicko 레이팅 편차 (RD)

Glicko rating deviation (RD shrinks with games, grows with inactivity)

  • Canvas
  • Python
  • Node.js

레이팅을 하나의 숫자가 아니라 평균 r과 불확실성 RD를 가진 분포로 다뤄, 경기를 할수록 RD가 줄어 레이팅 변화폭이 작아지고 쉬면 RD가 다시 커지는 Glicko 시스템을 보여 준다.

프롬프트

신규 플레이어(r=1500, RD=350)가 RD 60 상대 9명과 경기할 때마다 Glicko-1 공식(q=ln10/400, g(RD)=1/√(1+3q²RD²/π²), E, d², r'=r+q/(1/RD²+1/d²)·g(s−E), RD'=√(1/(1/RD²+1/d²)))으로 갱신해 정규분포 곡선과 95% 구간이 좁아지게 해줘. 이후 6기간 휴면 동안 RD=min(350, √(RD²+60²))로 다시 넓어지게 하고, 하단에 RD 이력 그래프(승 초록/패 빨강/휴면 보라 점)와 g(RD_opp)·E 값을 표시해줘.

라이브 데모 열기 — Glicko 레이팅 편차 (RD)

TrueSkill μ/σ 베이지안 갱신

TrueSkill Bayesian skill update (μ, σ, conservative μ − 3σ)

  • Canvas
  • Python
  • C#

실력을 평균 μ와 불확실성 σ의 정규분포로 두고 승패가 나올 때마다 v·w 함수로 두 분포를 갱신해, 신규 플레이어는 크게 움직이고 검증된 플레이어는 조금만 움직이며 순위는 보수적 값 μ−3σ로 매기는 방식을 보여 준다.

프롬프트

μ₀=25, σ₀=8.333, β=25/6, 무승부 없음으로 c=√(2β²+σA²+σB²), t=(μA−μB)/c, v=φ(t)/Φ(t), w=v(v+t), μA+=σA²/c·v, μB−=σB²/c·v, σ²×=(1−σ²/c²·w)를 계산해줘. 신규 A(25, 8.33)가 강자 B(30, 4)를 이기는 경우, 예상된 승리, 동급 대결 세 매치를 2.8초씩 보여 주며 두 가우시안 곡선이 easeInOutCubic으로 이동·수축하게 하고 축 위 μ−3σ 마커와 c·t·v·w 수치, 선수별 rank 값을 표시해줘.

라이브 데모 열기 — TrueSkill μ/σ 베이지안 갱신

서버 이동 검증 (스피드핵 탐지)

Server-side movement validation (speed-hack detection)

  • Canvas
  • Node.js
  • Unreal

서버가 패킷 사이 경과 시간 × 최대 속도 × 허용 오차로 이동 거리를 검증해 초과분은 잘라 내고 위반이 누적되면 되돌려(러버밴딩) 스피드핵을 막되, 정상 유저의 랙 버스트는 시간 기반이라 통과시키는 방식이다.

프롬프트

정상 레인과 ×1.6 스피드핵 레인을 만들고 10Hz 이동 패킷마다 서버가 Δx ≤ v_max(20px/s)·Δt·1.1을 검사하게 해줘. 초과하면 허용치까지만 반영(서버 위치 앰버 고스트)하고 위반 칸을 1개씩 채워 3개가 되면 REJECT → 클라이언트를 서버 위치로 되돌리고 flags를 올리며, 위반은 정상 패킷마다 0.25씩 감소시켜줘. 정상 레인은 0.4초 랙 버스트 뒤 몰려온 패킷도 'lag burst ✓'로 통과시키고, 하단에 패킷별 주장 속도 막대와 한도 점선을 그려줘.

라이브 데모 열기 — 서버 이동 검증 (스피드핵 탐지)

MMO 존 핸드오프 (공간 샤딩)

Spatial sharding with seamless zone handoff (MMO)

  • Canvas
  • SpatialOS
  • C++

월드를 구역별 서버로 나누고 경계 근처에서는 이웃 서버가 고스트 엔티티를 유지하다가, 플레이어가 히스테리시스 구간을 넘으면 권한과 클라이언트 연결을 다음 서버로 넘겨 끊김 없는 MMO를 만드는 기법이다.

프롬프트

탑다운 월드를 x=160 기준 ZONE A/B로 나누고 상단에 SERVER A/B 아이콘을 둬줘. 경계 ±18px 히스테리시스 띠에서 플레이어가 넘어갈 때만 권한을 바꾸고(왕복 진동 방지), 경계 근처 엔티티는 상대 서버 색 점선 고스트로 표시하며, 전환 순간 HANDOFF 1.8KB 패킷이 서버 사이를 날아가고 클라이언트 연결 점선이 새 서버로 easeInOutCubic 이동하며 'authority → B' 팝업을 띄워줘.

라이브 데모 열기 — MMO 존 핸드오프 (공간 샤딩)

물리 권한 이전 (소유권 전환)

Physics authority transfer (ownership on interaction)

  • Canvas
  • Unity
  • Photon

공유 물리 오브젝트를 건드린 플레이어에게 소유권을 넘겨 그 플레이어 화면에서는 지연 없이 시뮬레이션되게 하고, 멈추면 서버로 권한을 돌려주는 분산 권한 방식으로 상대는 100ms 과거로 보게 된다.

프롬프트

탑다운 경기장에서 공을 A가 0.8초, B가 2.8초, A가 4.8초에 차게 하고(속도 감쇠 e^(−1.6t)), 공과 링 색을 현재 소유자(A 시안/B 핑크/서버 회색)로 바꾸며 차는 순간 'OWNER → A' 링·팝업을 띄워줘. 비소유자가 보는 100ms 과거 고스트를 함께 그리고, 공이 멈춘 뒤 7.3초에 'at rest → SERVER'로 권한을 반환하며 하단에 소유권 타임라인 세그먼트와 커서를 표시해줘.

라이브 데모 열기 — 물리 권한 이전 (소유권 전환)

네트워크 LOD (거리별 업데이트 빈도)

Network LOD: update rate by distance

  • Canvas
  • Unreal
  • Unity

플레이어와 가까운 엔티티는 20Hz, 중간은 5Hz, 먼 엔티티는 1Hz로 업데이트 빈도를 낮춰 체감 품질은 유지하면서 대역폭을 크게 줄이는 리플리케이션 우선순위 기법이다.

프롬프트

이동하는 뷰어 주위에 반경 52px(20Hz)·100px(5Hz) 점선 링을 그리고 26개 엔티티를 원운동시키되 표시 위치는 floor(t·hz)/hz 시점으로 샘플링해 먼 엔티티일수록 뚝뚝 끊기게, 업데이트 순간 작은 링을 띄워줘. 실제 위치까지 얇은 선을 이어 오차를 보이고, 오른쪽 HUD에 티어별 개수와 균일 20Hz 대비 updates/s 막대·절감 %를 표시해줘.

라이브 데모 열기 — 네트워크 LOD (거리별 업데이트 빈도)

예측 발사체 생성 & 서버 확정

Predicted projectile spawn with server confirmation (prediction IDs)

  • Canvas
  • Unreal
  • Unity

발사 버튼을 누르면 클라이언트가 예측 ID를 붙인 발사체를 즉시 띄우고, 서버가 만든 권위 발사체가 복제돼 오면 같은 ID로 묶어 합치거나 서버가 거절하면 예측 발사체를 지워 되돌리는 기법이다.

프롬프트

CLIENT/SERVER 두 레인에 사수와 표적을 두고 RTT 240ms, 발사체 150px/s로 만들어줘. 1발째는 점선 'pred id 17'로 즉시 날아가고 서버 발사체가 120ms 늦게 생성돼 240ms에 복제되면 'MATCH id 17 → merge'로 실선이 되며 예측 히트 이펙트 뒤 −25 confirmed가 뜨게, 2발째는 서버가 쿨다운으로 거절해 예측 발사체가 연기처럼 흩어지며 'ROLLBACK id 18'과 예측 탄약 복구를 보여줘.

라이브 데모 열기 — 예측 발사체 생성 & 서버 확정

피커스 어드밴티지

Peeker's advantage (latency + interpolation asymmetry)

  • Canvas
  • Source Engine
  • Unity

모서리에서 튀어나오는 쪽은 자기 화면에서 즉시 상대를 보지만, 기다리는 쪽은 상승 지연·틱·하강 지연·보간을 합친 시간만큼 늦게 보게 되어 먼저 쏘는 쪽이 유리해지는 비대칭을 보여 준다.

프롬프트

PEEKER 화면과 DEFENDER 화면에 같은 벽과 두 플레이어를 그리고 0.25배 슬로모션으로 피커가 120px/s로 벽을 벗어나게 해줘. 디펜더 화면은 피커를 up 30 + tick 8 + down 30 + interp 100 = 168ms 늦게 그려, 피커가 노출 80ms 뒤 쏜 총에 디펜더가 '보기도 전에 사망'하게 하고, 하단 타임라인에 peeker sees / fires / defender dead / defender sees와 advantage 구간을 표시해줘.

라이브 데모 열기 — 피커스 어드밴티지

혼잡 회피 (30↔10 pps 모드 전환)

Congestion avoidance: good/bad mode send-rate switching

  • Canvas
  • C++
  • UDP

RTT가 임계값을 넘으면 전송률을 30pps에서 10pps로 즉시 낮추고, 좋은 상태가 페널티 시간만큼 이어져야 복귀하며 금방 다시 나빠지면 페널티를 두 배로 늘리는 단순하고 견고한 UDP 혼잡 회피 규칙이다.

프롬프트

40초 RTT 시나리오를 ×5 압축으로 그려 80ms 기본에 330ms·320ms·290ms 구간을 넣고, RTT > 250ms면 BAD(10pps), BAD에서 좋은 상태가 penalty 초 연속되면 GOOD(30pps)로 복귀하게 해줘. GOOD 복귀 10초 안에 다시 BAD가 되면 penalty ×2(최대 60s), GOOD이 10초 지속되면 ÷2(최소 1s)로 하고, RTT 그래프·모드 띠·전송 간격이 바뀌는 패킷 스트림·penalty/good-for 바를 보여줘.

라이브 데모 열기 — 혼잡 회피 (30↔10 pps 모드 전환)

패킷 분할·재조립 (MTU)

Packet fragmentation & reassembly over UDP (MTU ≈ 1200 B)

  • Canvas
  • C++
  • UDP

MTU보다 큰 스냅샷을 헤더(seq, 조각 id, 개수)가 붙은 1200B 조각들로 나눠 보내고 수신 측 버퍼에서 모두 모이면 재조립하되, 한 조각만 잃어도 패킷 전체를 버리는 구조와 그 손실 확률을 보여 준다.

프롬프트

4200B 스냅샷 #57을 1200·1200·1200·600B 조각으로 easeInOutCubic 분리해 0.15초 간격으로 보내고 수신 재조립 버퍼 4칸이 채워지면 'REASSEMBLED 4200B'로 합쳐줘. #58은 3/4 조각을 중간에 잃게 해 버퍼 칸이 빈 채로 1.1초 타임아웃 바가 차오른 뒤 'DROPPED #58'이 되게 하고, 하단에 5% 손실에서 P(4조각 모두 도착)=0.95⁴=81.5% 계산을 표시해줘.

라이브 데모 열기 — 패킷 분할·재조립 (MTU)

릴레이 서버 폴백 (TURN)

TURN relay fallback when NAT traversal fails

  • Canvas
  • WebRTC
  • C++

대칭형 NAT 때문에 홀펀칭이 실패하면 ICE가 TURN 릴레이 서버로 폴백해 모든 패킷을 서버 경유로 중계하는 과정과, 그 대가인 추가 지연·서버 대역폭 비용을 보여 준다.

프롬프트

PEER A–NAT A(port-restricted)–NAT B(symmetric)–PEER B를 가로로, 위쪽에 TURN :3478 서버를 배치해줘. 0~2.7초에는 양쪽 punch 패킷이 0.6초 간격으로 NAT에서 X로 사라지며 '포트가 목적지마다 바뀜 :5000 → :61022' 경고를, 2.75초에 ALLOCATE 패킷과 'allocation ✓' 팝업 후 A→NAT→TURN→NAT→B 경로로 0.16초 간격 양방향 패킷을 흘려줘. 하단에 RTT direct 46ms ✗ vs relay 74ms(+28) 막대와 10명 × 48kbps × 2 = 0.96Mbps ≈ 0.43GB/h 릴레이 비용, 누적 relayed KB를 표시해줘.

라이브 데모 열기 — 릴레이 서버 폴백 (TURN)

지역 서버 선택 · 핑 측정 · 확장

Region selection by ping with population weighting & queue region expansion

  • Canvas
  • Node.js
  • PlayFab

접속 시 각 리전에 핑을 3번 보내 중앙값 RTT를 재고 인구 가중 점수로 선호 리전을 고른 뒤, 대기 시간이 길어질수록 허용 RTT를 넓혀 이웃 리전까지 매칭 풀에 넣는 흐름을 보여 준다.

프롬프트

점묘 세계 지도에 ap-ne(18ms·520명), ap-se(64ms·1.4k), us-w(126ms), oce(138ms), eu-c(238ms) 서버를 두고 YOU에서 0.7초 간격 3라운드 핑 패킷을 왕복시켜 표에 RTT 중앙값과 score = RTT + 80·(1 − pop/1000)을 채워 최저 점수 리전을 ★로 표시해줘. 이후 대기 시간 0→20초 동안 허용 RTT = 30 + 3·wait로 녹색 점선 링(0.45px/ms)을 키워 링 안 리전을 풀에 넣고, ±100 MMR 후보 슬롯 8칸이 차면 'MATCH FOUND · ap-se · 64ms'를 띄워줘.

라이브 데모 열기 — 지역 서버 선택 · 핑 측정 · 확장

패킷 손실 시각화 · 랜덤 vs 버스트

Random vs burst packet loss (Gilbert–Elliott model) on interpolated movement

  • Canvas
  • Unity
  • C++

평균 손실률이 같아도 독립 손실은 보간이 한 칸씩 메워 주지만 Gilbert–Elliott 버스트 손실은 연속으로 빠져 보간 버퍼가 바닥나 멈췄다 튀는 차이를 손실률 슬라이더와 함께 보여 준다.

프롬프트

20Hz 스냅샷·100ms 보간 버퍼로 그리는 원격 엔티티 두 레인을 만들고, 손실률 슬라이더를 2%→22%로 easeInOutCubic 이동시켜줘. 위 레인은 매 패킷 독립 확률 L로, 아래 레인은 2상태 Gilbert–Elliott(p(G→B)=L·r/(1−L), r(B→G)=0.3, 평균 버스트 3.3개)로 잃게 하고, 실제 경로 고스트·렌더 궤적·오차선, 버퍼가 비면 'FREEZE n ms', 최근 46패킷 손실 스트립과 lost/60·longest run·max jump px를 표시해줘.

라이브 데모 열기 — 패킷 손실 시각화 · 랜덤 vs 버스트

대역폭 예산 · 플레이어 수 · 틱

Bandwidth budget: bytes per entity × entities × tick rate

  • Canvas
  • Unreal
  • Unity

엔티티당 바이트 × 보내는 엔티티 수 × 틱레이트로 클라이언트별 다운스트림 kbps와 서버 업스트림을 계산하고, 플레이어 수·틱레이트 증가와 AOI 컬링이 예산을 어떻게 바꾸는지 그래프로 보여 준다.

프롬프트

왼쪽 경기장에서 플레이어 수를 8→100→64로 바꾸고 4.6초에 틱을 30→60Hz로, 6.2초에 반경 36px AOI 원을 켜서 원 밖 점을 흐리게 해줘. 오른쪽에 (헤더 32B + 보낸 엔티티 × 24B) × tick × 8 = kbps 계산식과 서버 업로드 = per-client × N Mbps를 실시간으로, 아래 그래프에 전체 전송(빨강)·AOI(초록) 곡선, 256kbps 예산 점선, 현재 설정 마커와 'tick ×2'·'AOI −n%' 팝업을 그려줘.

라이브 데모 열기 — 대역폭 예산 · 플레이어 수 · 틱

스냅샷 동기 vs 이벤트 동기

State snapshots vs reliable discrete events (late join & missed one-shots)

  • Canvas
  • Unity
  • Mirror

문 상태를 매 스냅샷에 반복해 담는 방식은 손실·늦은 접속에 강하지만 스냅샷 사이의 순간 이벤트를 놓치고, 변화만 신뢰 이벤트로 보내는 방식은 대역폭이 적고 순간 효과를 살리지만 늦게 들어온 클라이언트가 상태를 모르는 차이를 보여 준다.

프롬프트

두 레인에 SERVER·CLIENT A·JOINER B의 문을 그리고 1초에 문이 열리고 2.6초에 0.1초짜리 폭발이 일어나게 해줘. SNAPSHOT 레인은 250ms마다 door=0/1 패킷을 보내 하나를 잃어도 다음 것으로 열리고 4.4초에 접속한 B도 첫 스냅샷으로 바로 열리지만 폭발은 'boom? ✗'로 놓치게, EVENT 레인은 DoorOpened를 한 번 잃고 400ms 뒤 재전송해 늦게 열리며 Explosion은 보이지만 B는 'MISSED EVENT ✗'로 닫힌 문을 보게 해줘.

라이브 데모 열기 — 스냅샷 동기 vs 이벤트 동기

신뢰 · 비신뢰 RPC 채널 선택

Reliable vs unreliable RPC channels & head-of-line blocking

  • Canvas
  • Unreal
  • Netcode for GameObjects

모든 RPC를 신뢰·순서 채널 하나로 보내면 패킷 하나만 잃어도 뒤의 이펙트까지 재전송 동안 멈췄다 몰려오는 HOL 블로킹이 생기므로, 장식 이펙트는 비신뢰로·게임플레이 판정만 신뢰 순서로 나누는 이유를 보여 준다.

프롬프트

초당 5개 RPC(4번째마다 DMG, 나머지 FX)를 편도 250ms로 보내고 #8 #19 #27을 잃게 해줘. 위 레인은 전부 신뢰 순서라 재전송(RTO 600ms) 동안 수신 버퍼 칸에 뒤 메시지가 쌓여 'HOL BLOCKED'와 붉은 정지 구간이 생기고 칩이 한꺼번에 몰려 배달되며, 아래 레인은 FX 손실은 그냥 건너뛰고 DMG만 자체 신뢰 채널에서 재전송되게 해줘. 오른쪽에 45px/s로 흐르는 배달 타임라인과 max stall ms를 표시해줘.

라이브 데모 열기 — 신뢰 · 비신뢰 RPC 채널 선택

히트 판정 검증 · 서버 허용 오차

Server-side hit validation with tolerances (client-reported hitscan)

  • Canvas
  • Unreal
  • Unity

클라이언트가 보낸 히트 주장을 서버가 사수 위치 오차, 되감은 히트박스와 레이 사이 거리, 시야 차단, 연사 간격으로 재검증해 작은 동기 오차는 허용하고 벽 너머 사일런트 에임 같은 치트는 거부하는 과정이다.

프롬프트

서버 탑다운 뷰에 사수·벽·표적을 두고 LEGIT/DESYNC/CHEAT 세 케이스를 2.9초씩 보여줘. HIT{id:7,bone:head} 패킷 도착 → 표적을 RTT만큼 되감기 → 레이와 히트박스 + 0.15m 허용 링 표시 후, 오른쪽 체크리스트에 shooter pos Δ ≤ 0.50m, ray→hitbox ≤ 0.15m, line of sight, fire interval ≥ 90ms를 0.22초 간격으로 ✓/✗ 점등하고 HIT CONFIRMED / ACCEPT (tolerance) / REJECT · flag +1 결과 카드를 띄워줘(1m = 20px).

라이브 데모 열기 — 히트 판정 검증 · 서버 허용 오차

입력 지연 숨기기 · 로컬 연출 선행

Hiding input latency with local cosmetic feedback (cancel on server deny)

  • Canvas
  • Unity
  • Unreal

버튼을 누르면 시전 모션·차지 이펙트·사운드는 로컬에서 즉시 재생하고 데미지·자원 차감 같은 결과만 서버 확정을 기다리며, 서버가 거절하면 연출을 피즐로 취소하고 예측 차감을 되돌리는 체감 지연 숨기기 기법이다.

프롬프트

WAIT FOR SERVER와 LOCAL COSMETIC FIRST 두 레인에서 0.5초·2.9초·5.3초에 스킬을 누르게 하고 RTT 300ms로 만들어줘. 위 레인은 300ms 뒤에야 차지(0.35초)·발사체(0.45초)·−42가 시작되고 세 번째는 'DENIED'만 뜨게, 아래 레인은 누르는 즉시 차지 오브와 사운드 링이 시작되고 세 번째는 거절 응답 순간 입자가 흩어지며 'FIZZLE · 서버 거절 → 연출 취소'와 예측 마나 25가 복구되게 해줘. 하단 타임라인에 press/ack/deny 마커를 그려줘.

라이브 데모 열기 — 입력 지연 숨기기 · 로컬 연출 선행

지연 보상 상한 (리와인드 캡)

Lag compensation rewind cap (max time-warp window)

  • Canvas
  • Source Engine
  • Unreal

서버가 되감아 주는 시간을 200ms 같은 상한으로 묶어, 핑이 높은 플레이어는 더 이상 과거 화면 기준으로 판정받지 못하고 목표를 앞서 조준해야 하며 그만큼 맞는 쪽이 엄폐 뒤 사망에서 보호받는 공정성 곡선을 보여 준다.

프롬프트

위 그래프 x=핑 0~400ms에 needed = RTT + interp 50ms 점선과 applied = min(needed, 200ms) 실선을 그리고 상한 위 영역을 붉게 '리드 필요 · 맞는 쪽 보호'로 칠한 뒤 흰 커서로 핑을 스윕해줘. 아래에 핑 40/120/220/350 네 줄을 두고 표적을 x = 186 + 100·sin(0.9t)로 움직이며 사수 조준(화면 위치)과 서버가 검사하는 히트박스(±4.5px)를 함께 그려, 상한을 넘는 줄만 lead 70ms/200ms 간격과 MISS가 나게 해줘.

라이브 데모 열기 — 지연 보상 상한 (리와인드 캡)

클라이언트 신뢰 경계 매트릭스

Client trust boundary matrix (what the client may decide vs server-verified)

  • Canvas
  • Unreal
  • Node.js

위치·피해량·히트 판정·인벤토리·쿨다운·조준·이펙트를 클라이언트 결정/예측+서버 검증/서버 전용 칸에 배치하고, 변조 시도를 행마다 쏴서 클라이언트를 믿는 칸에서만 익스플로잇이 터지는 것을 보여 주는 보안 설계 도표다.

프롬프트

7행 × 3열(CLIENT 결정, 예측 + 서버 검증, SERVER 전용) 매트릭스를 만들고 0.3초부터 붉은 변조 패킷을 0.62초 간격으로 각 행 칩에 쏴줘. NAIVE TRUST 단계에서는 전부 client 칸이라 teleport·one-shot 9999·벽 너머 히트·아이템 복사·쿨다운 무시가 EXPLOIT로 터지고, 4.6초에 칩이 easeInOutCubic으로 hardened 칸으로 이동한 뒤 다시 쏘면 BLOCKED, 조준은 '텔레메트리 탐지뿐', 이펙트는 harmless로 표시하며 exploits n/5 태그를 갱신해줘.

라이브 데모 열기 — 클라이언트 신뢰 경계 매트릭스

매칭 품질 · 핑 vs 실력 창

Matchmaking quality: skill gap vs latency window with quality score

  • Canvas
  • Node.js
  • OpenMatch

후보를 MMR 차이와 매치 핑 두 축에 놓고 q = e^−(Δ/200)²·e^−(ping/100)² 품질 히트맵 위에서 대기 시간에 따라 실력 창·핑 창은 넓히고 최소 품질은 낮춰 가장 좋은 후보와 매칭하는 2차원 트레이드오프를 보여 준다.

프롬프트

x = ΔMMR −400~+400, y = ping 0~200ms 평면에 22×13 품질 히트맵을 깔고 q ≥ q_min 칸을 초록으로 칠해줘. 46명의 후보가 시간차로 등장(링)하고, 노란 창은 Wd = 60 + 10·wait, Wp = 35 + 3.5·wait로 커지며 q_min = 0.85 − 0.014·wait로 내려가게 3배속으로 돌려, 창 안 최고 후보를 점선 원으로 추적하다 q ≥ q_min이 되는 순간 'MATCH Δ+n MMR · n ms · q' 카드를 띄워줘.

라이브 데모 열기 — 매칭 품질 · 핑 vs 실력 창

보이스 챗 지터 버퍼 · PLC

Voice chat: 20 ms frames, adaptive jitter buffer & packet loss concealment

  • Canvas
  • WebRTC
  • Opus

20ms 오디오 프레임 패킷이 들쭉날쭉 도착할 때 적응형 지터 버퍼가 재생 지연을 늘렸다 천천히 줄이고, 잃거나 늦은 프레임은 직전 파형을 감쇠 반복하는 PLC로 메우는 보이스 챗 수신 파이프라인을 보여 준다.

프롬프트

50pps 음성 패킷이 송신→수신으로 날아가게 하고 3.3초 부근에 최대 120ms 지터 스파이크, 5.6초에 4프레임 연속 손실을 넣어줘. 재생 지연 목표 = 최근 1초 최대 전송 지연 + 15ms로 두고 늘릴 때는 10ms당 2.5ms(time-stretch, 보라), 줄일 때는 0.5ms씩만 줄이며, 버퍼 칸·target ms·전송 지연 점 그래프와 재생 지연 선, 하단 재생 파형을 decoded(시안)/PLC(앰버, 0.75^n 감쇠)/stretch(보라)로 칠해줘.

라이브 데모 열기 — 보이스 챗 지터 버퍼 · PLC

재접속 · 상태 복원

Mid-match reconnect: AFK grace, bot takeover, full snapshot + delta catch-up

  • Canvas
  • Unreal
  • Photon

매치 도중 연결이 끊기면 서버는 슬롯을 유지한 채 유예 시간 뒤 봇이 대신 조종하고, 재접속하면 전체 스냅샷을 받은 뒤 밀린 델타를 빠르게 재생해 서버 틱을 따라잡고 조작을 돌려받는 흐름이다.

프롬프트

SERVER·CLIENT 두 탑다운 화면과 하단 타임라인(LIVE/GRACE/BOT/SNAP/Δ/LIVE)을 만들고 1.4초에 끊김(X, 클라이언트 화면 정지 'CONNECTION LOST'), 서버는 AFK 유예 바(15s 압축) 뒤 3초부터 BOT 태그로 대신 이동시켜줘. 5초에 HELLO token → SNAPSHOT 38KB 조각 4개 → 5.6초부터 Δ×12 패킷으로 ×1.4 빨리감기해 6.6초에 따라잡고 'control → player'를 띄우며, 서버 틱 − 클라이언트 틱 차이 그래프를 붉은 면적으로 그려줘.

라이브 데모 열기 — 재접속 · 상태 복원

게임 백엔드 서비스 흐름 · 재시도

Game backend services: auth → matchmaking → fleet allocation → persistence (retries & idempotency)

  • Canvas
  • Node.js
  • AWS GameLift

로그인, 매칭 티켓, 게임 서버 할당, 경기 결과 저장, 리더보드 갱신을 각각 다른 서비스가 맡는 백엔드에서 요청이 흐르는 순서와 할당 실패 시 백오프 재시도, 저장 타임아웃 시 멱등 키 재시도를 보여 준다.

프롬프트

CLIENT–GATEWAY–AUTH/MATCHMAKER/FLEET–GS seoul/GS tokyo–PERSIST/LEADER 노드를 배치하고 POST /login → 200 JWT → enqueue → ticket #8812 → allocate seoul이 503 FULL로 실패 → 200ms 백오프 바 → retry tokyo 성공 → match found 순서로 패킷을 흘려줘. 4.8~7초엔 CLIENT↔GS tokyo UDP 패킷 루프, 7초엔 POST /results가 500ms 타임아웃으로 실패한 뒤 같은 Idempotency-Key로 재시도해 201 stored와 ZINCRBY +25가 되게 하고, 하단에 최근 4줄 요청 로그를 표시해줘.

라이브 데모 열기 — 게임 백엔드 서비스 흐름 · 재시도

웹소켓 vs WebRTC 데이터 채널

WebSocket (TCP) head-of-line blocking vs WebRTC unreliable data channel for browser games

  • Canvas
  • WebSocket
  • WebRTC

브라우저 게임에서 웹소켓은 TCP라 패킷 하나를 잃으면 재전송될 때까지 뒤 패킷까지 커널 버퍼에 묶여 지연이 톱니처럼 튀고, WebRTC 데이터 채널을 비순서·무재전송으로 열면 잃은 스냅샷만 건너뛰어 지연이 평평한 차이를 보여 준다.

프롬프트

20Hz 상태 패킷을 편도 50ms로 두 레인에 보내고 #22 #23 #70 #118을 잃게 해줘. WEBSOCKET 레인은 RTO 250ms 재전송까지 뒤 패킷이 'kernel buf n'에 쌓여 원격 캐릭터가 'STALL n ms'로 멈췄다 몰려가고, DATACHANNEL(ordered:false, maxRetransmits:0) 레인은 보간으로 매끄럽게 이어지게 해줘. 하단 4초 그래프에 패킷별 배달 지연 점(TCP 빨강 톱니 최대 ~300ms, UDP 초록 50ms 평탄, 손실은 X)을 그려줘.

라이브 데모 열기 — 웹소켓 vs WebRTC 데이터 채널

네트워크 컨디셔너 프로파일 테스트

Network condition simulation profiles (latency, jitter, loss) in dev builds

  • Canvas
  • Unity
  • Unreal

개발 빌드에서 지연·지터·손실을 인위로 넣는 네트워크 컨디셔너로 LAN·Wi-Fi·3G·불량 회선 프리셋을 걸어 같은 경기가 각 환경에서 얼마나 끊기고 어긋나는지 나란히 비교하는 테스트 방법이다.

프롬프트

2×2 패널에 LAN(2±1ms, 0%), WI-FI(20±12ms, 1%), 3G(120±50ms, 3%), BAD(250±120ms, 10%) 프리셋을 걸고 같은 8자 경로로 움직이는 원격 엔티티를 20Hz 스냅샷·100ms 보간 버퍼로 렌더해줘. 각 패널에 실제 위치 고스트와 최근 1초 렌더 궤적, 버퍼가 비면 HOLD, 오른쪽에 err px·lost/60·late·reorder 수치와 최근 20패킷 도착 지연 막대(손실은 빨강)를 표시하고, 캡션에 Unity Network Simulator/Unreal PktLag·PktLoss 같은 설정임을 적어줘.

라이브 데모 열기 — 네트워크 컨디셔너 프로파일 테스트

비트 패킹 · Varint & ZigZag

Bit packing: varint (LEB128) & ZigZag encoding for signed deltas

  • Canvas
  • C++
  • C#

스냅샷 필드를 고정 4바이트 int32 대신 7비트씩 끊는 varint로, 부호 있는 델타는 ZigZag로 접은 뒤 varint로 써서 패킷 바이트를 절반 이하로 줄이는 직렬화 기법이다.

프롬프트

엔티티 필드 5개(id u32, dx·dy·yaw i32, hp u32)를 세 레인에서 INT32(4바이트 리틀 엔디언) · VARINT(7비트+MSB 연속 비트, 음수는 2의 보수라 5바이트) · ZIGZAG+VARINT(zz(n)=(n<<1)^(n>>31))로 인코딩해줘. 바이트 셀을 72ms 간격으로 커서가 채우며 16진수 값과 연속 비트(흰 점)를 표시하고, 레인 끝에 20B → 14B → 7B 같은 총 바이트와 −65% 절감을 팝업, 하단에 0→0, −1→1, 1→2 ZigZag 매핑표를 두고 2.7초마다 다른 값 세트로 바꿔줘.

라이브 데모 열기 — 비트 패킹 · Varint & ZigZag

넷 도먼시 (휴면 액터 복제 생략)

Net dormancy: skip replication checks for sleeping actors until flushed

  • Canvas
  • Unreal
  • Unity

상자·문·아이템처럼 거의 변하지 않는 복제 액터를 휴면 상태로 두어 서버가 매 넷 틱마다 속성 비교를 하지 않게 하고, 플레이어가 상호작용할 때만 깨워 한 번 보내는 서버 CPU 절감 기법이다.

프롬프트

탑다운 맵에 정적 액터 22개(상자·문·픽업)와 움직이는 플레이어 3명을 두고, 플레이어 반경 20px 안에 들어오면 FlushNetDormancy로 깨워 매 넷 틱(10Hz) 비교 링을 그리고, 벗어난 뒤 1.5초 타임아웃 원호가 다 줄면 DORM_DormantAll로 돌아가 z 표시와 함께 어둡게 해줘. 오른쪽 HUD에 ALWAYS 25 vs WITH DORMANCY n 체크 수, 최근 4초 막대 그래프, 액터당 6µs × 접속 64명 비교 비용(9.6ms → 몇 ms)을 표시해줘.

라이브 데모 열기 — 넷 도먼시 (휴면 액터 복제 생략)

진행 중 매치 백필

In-progress match backfill: ticket with target MMR, widening window & progress cutoff

  • Canvas
  • Node.js
  • GameLift

경기 도중 이탈자가 생기면 재접속 유예가 끝난 뒤 빈 슬롯용 백필 티켓을 만들어 팀 평균을 맞추는 목표 MMR과 점점 넓어지는 허용 범위, 핑·진행률 조건으로 대기열에서 대체 인원을 채우는 매치메이킹 기법이다.

프롬프트

5v5 슬롯 보드에서 0.9초에 B3가 이탈해 LEFT로 깜박이고, 재접속 유예 60s(압축) 뒤 1.6초에 백필 티켓(team B, target = ΣA − ΣB₄ = 1450, W(t)=100+50·t, ping ≤ 80ms, 진행률 < 70%)을 띄워줘. 후보 3명이 0.9초 간격으로 들어와 MMR 축 위 허용 밴드에 떨어지며 Kite(Δ370 MMR ✗) · Moss(ping 124 ✗) · Juno(Δ135 ≤ 227 ACCEPT) 도장을 찍고, 수락되면 join 패킷이 슬롯으로 날아가 초록으로 채워지며 팀 평균 차이 Δavg와 fill time, 38KB 늦은 합류 스냅샷을 표시해줘.

라이브 데모 열기 — 진행 중 매치 백필

RTT 추정 · SRTT · RTTVAR · RTO

RTT estimation with SRTT / RTTVAR smoothing and retransmission timeout (Jacobson/Karels)

  • Canvas
  • C++
  • ENet

핑 샘플을 그대로 쓰지 않고 지수 평균 SRTT와 편차 RTTVAR로 다듬어 화면 핑 표시·보간 지연·재전송 타임아웃 RTO를 정하는 표준 방식으로, 이상치와 혼잡 구간에서도 값이 안정적이다.

프롬프트

160ms마다 ping/pong 패킷을 주고받아 RTT 샘플을 얻고 SRTT ← 7/8·SRTT + 1/8·R, RTTVAR ← 3/4·RTTVAR + 1/4·|SRTT−R|, RTO = max(50, SRTT + 4·RTTVAR)로 갱신해줘(RFC 6298). 그래프에 샘플 점, SRTT 초록선, ±RTTVAR 보라 밴드, RTO 빨간 점선을 그리고 +160ms 이상치 1개, 60→130ms 혼잡 구간, 손실 1개(LOST → RTO 후 재전송)를 넣어 오른쪽 HUD에 R·SRTT·RTTVAR·RTO 숫자를 실시간 표시해줘.

라이브 데모 열기 — RTT 추정 · SRTT · RTTVAR · RTO

커넥트 토큰 · 챌린지 핸드셰이크

Connect-token handshake with challenge cookie (anti-spoofing, no amplification)

  • Canvas
  • C
  • netcode.io

백엔드가 발급한 암호화 커넥트 토큰과 챌린지 쿠키 왕복을 거쳐야만 서버 슬롯을 할당해, IP 위조 패킷과 반사 증폭 공격으로 서버 자원이 낭비되지 않게 하는 UDP 게임 서버 연결 절차다.

프롬프트

BACKEND · CLIENT · SERVER · SPOOFER 네 생명선의 시퀀스 다이어그램으로 HTTPS 로그인 → connect token(AEAD, 30초 만료) → REQUEST 1078B → CHALLENGE 308B(암호화 쿠키, 아직 슬롯 미할당) → RESPONSE → CONNECTED slot 7/64 순서로 0.4초짜리 패킷 화살표를 그려줘. 중간에 위조 IP의 60B 요청은 1078B 미만이라 DROP, 재사용 토큰 요청은 챌린지가 위조 IP로 가 응답이 없게 하고 308 ≤ 1078 → 증폭 0.29×를 표시, 하단에 challenge 전 서버 상태 0B · 차단 수 · 연결 수를 보여줘.

라이브 데모 열기 — 커넥트 토큰 · 챌린지 핸드셰이크

토큰 버킷 RPC 레이트 리밋

Token-bucket rate limiting of client RPCs with violation-based kick

  • Canvas
  • Node.js
  • Unity

클라이언트별 토큰 버킷으로 순간 버스트는 허용하되 평균 속도를 넘는 RPC는 버리고, 위반이 일정 횟수를 넘으면 연결을 끊어 매크로·패킷 플러딩으로부터 서버를 지키는 기법이다.

프롬프트

용량 10, 초당 5토큰 충전, RPC 1회 = 1토큰인 버킷을 PLAYER(가끔 6~10연타 버스트)와 MACRO(초당 25회 연타) 두 레인에 두고, 동전 10개가 차고 빠지는 버킷 그림과 최근 3초 ok/drop 점 타임라인, 토큰 잔량 그래프를 그려줘. 거부될 때마다 빨간 X로 튕기고 3초 창 위반 수 막대가 40에 도달하면 MACRO 레인을 어둡게 덮으며 KICK · RPC FLOOD 도장과 60초 재접속 금지를 표시해줘.

라이브 데모 열기 — 토큰 버킷 RPC 레이트 리밋

서브틱 입력 타임스탬프

Sub-tick input timestamps: evaluate commands at tick + fraction

  • Canvas
  • Source 2
  • Unity

클릭·점프 같은 입력에 틱 번호와 틱 내부 분수 시각을 함께 보내 서버가 그 시점으로 월드를 보간해 판정하므로, 낮은 틱레이트에서도 다음 틱 위치로 판정해 생기는 빗나감을 없애는 기법이다.

프롬프트

20Hz(50ms) 틱 눈금자를 슬로모션 ×0.25로 흘리고 빠르게 좌우로 움직이는 표적에 세 번 사격해줘(틱 4+0.24, 21+0.62, 29+0.9). TICK-QUANTIZED 레인은 다음 틱 위치로 판정해 err 10.1px · 6.3px MISS(분수 0.9인 세 번째는 0.8px라 HIT), SUB-TICK 레인은 lerp(tick n, tick n+1, f)로 판정해 HIT을 띄우고, 표적 아래에 서버가 아는 틱 스냅샷 다이아몬드와 레인 오른쪽에 판정식·오차 px를 표시해줘.

라이브 데모 열기 — 서브틱 입력 타임스탬프

랙 스위치 탐지 · 명령 시간 예산

Lag-switch detection: freeze on silence and cap burst commands by a real-time budget

  • Canvas
  • Unreal
  • C++

송신을 일부러 끊었다가 몰아서 보내는 랙 스위치를, 침묵 중에는 외삽하지 않고 동결하며 재개 시에는 실제 경과 시간만큼의 명령 예산만 수락하고 나머지는 버려 무력화하는 서버 검증 기법이다.

프롬프트

클라이언트가 20 cmd/s로 보내다 2.2~3.6초 동안 송신을 막아(HELD 카운트) 로컬에서는 적 뒤로 돌아가고, 3.65초에 28개를 한꺼번에 보내게 해줘. SERVER 패널은 침묵 동안 FROZEN · 외삽 안 함으로 멈추고, 명령 1개 = 50ms인 시간 예산(최대 250ms)만큼 5개만 수락해 23개를 DROP한 뒤 클라이언트를 되돌리는 CORRECTED 러버밴드를 보여 주고, 상단 패킷 타임라인·예산 막대·의심 점수 막대를 표시해줘.

라이브 데모 열기 — 랙 스위치 탐지 · 명령 시간 예산

각도 보간 래핑 (최단 호)

Angle interpolation wrap-around: shortest-arc lerp vs naive (yaw 359°→2°)

  • Canvas
  • Unity
  • Godot

네트워크로 받은 회전 각도를 보간할 때 359°와 2° 사이를 그냥 lerp하면 반대 방향으로 한 바퀴 도는 버그를, 차이를 [−180,180)으로 감싸 최단 호로 보간해 없애는 기법이다.

프롬프트

원격 포탑의 yaw를 0° 부근에서 ±44° 흔들며 10Hz 스냅샷·8비트 양자화(yaw·256/360)·100ms 보간 지연으로 받아, NAIVE LERP 다이얼은 0°/360° 경계를 넘을 때마다 SPIN!으로 크게 돌고 SHORTEST ARC 다이얼은 a + wrap(b−a)·α, wrap(d)=((d mod 360)+540) mod 360 − 180으로 부드럽게 따라가게 해줘. 각 다이얼에 받은 스냅샷 점·실제 각도 점선·err°, 하단에 최근 3초 signed yaw 그래프(naive 스파이크 vs shortest vs true)와 쿼터니언 dot<0이면 부호 반전 메모를 넣어줘.

라이브 데모 열기 — 각도 보간 래핑 (최단 호)

서버 틱 예산 · 과부하 대응

Server tick budget overrun: catch-up spiral vs adaptive replication shedding

  • Canvas
  • Unreal
  • Unity

플레이어가 늘어 서버 한 틱 처리 시간이 예산(30Hz면 33.3ms)을 넘을 때 밀린 틱을 몰아 처리해 지연이 쌓이는 대신, 시뮬레이션은 지키고 복제 예산을 남은 시간으로 줄여 버티는 서버 성능 관리 기법이다.

프롬프트

플레이어 수를 20→100으로 늘리며 틱 비용 = sim(4+0.06N) + phys(3+0.05N) + rep(0.0028N²) ms를 최근 60틱 누적 막대(파랑·보라·노랑)로 그리고 33.3ms 예산 점선을 그어줘. NAIVE CATCH-UP 레인은 초과분이 빨갛게 솟고 behind 누적 초·eff Hz·틱당 입력 지연을, ADAPTIVE 레인은 rep을 33.3 − 2ms 여유 − sim − phys로 잘라 예산 아래에 붙이고 복제 비율 %와 먼 액터 전송률 15Hz → 감소값을 표시해줘.

라이브 데모 열기 — 서버 틱 예산 · 과부하 대응

롤백 재시뮬 CPU 예산

Rollback resimulation CPU budget: max rollback frames per 16.67 ms frame

  • Canvas
  • GGPO
  • C++

롤백 넷코드에서 예측이 틀린 프레임마다 저장 상태를 불러와 R프레임을 다시 시뮬레이션하는 비용이 60fps 한 프레임(16.67ms) 안에 들어가야 하므로, 최대 롤백 깊이를 계산해 넘는 지연은 입력 딜레이로 돌리는 튜닝 기법이다.

프롬프트

핑을 40→260ms로 올리며 20% 확률로 예측 실패 프레임을 만들고, 상단에 최근 12프레임 세이브스테이트 링(LOAD 슬롯 노랑, resim 구간 파랑, 한도 초과 빨강)을, 중간에 render 5.5 + save 0.4 + load 0.35 + sim 1.3×(1+R) ms 가로 예산 막대와 16.67ms 기준선을 그려줘. R_max = ⌊(16.67−5.5−0.4−0.35)/1.3⌋−1 = 7을 표시하고, 하단에 최근 120프레임 프레임타임을 uncapped(빨강, 드롭 틱) vs cap 7f(초록) 두 선으로 비교하며 넘친 프레임 수만큼 +입력 딜레이 f를 보여줘.

라이브 데모 열기 — 롤백 재시뮬 CPU 예산

연결 품질 HUD · 히스테리시스

Connection quality HUD: EWMA ping bars and hysteresis warnings (no flicker)

  • Canvas
  • Unity
  • Unreal

화면 구석의 신호 막대·핑·손실·고지연 경고를 원시 샘플이 아니라 지수 평균과 진입/이탈 임계값·최소 유지 시간으로 판단해, 경고 아이콘이 깜박이지 않고 실제 회선 문제만 알려 주는 HUD 설계 기법이다.

프롬프트

게임 화면 우상단에 신호 막대 4칸(EWMA 핑 <60/100/150ms 기준), 핑 숫자, 최근 2초 손실 2% 초과 시 LOSS %, 고지연 경고(EWMA 140ms 초과 진입, 110ms 미만 + 2초 유지 후 해제)를 넣고, 우하단에는 raw > 125ms로만 판단해 깜박이는 NAIVE 표시와 토글 횟수를 비교해줘. 하단 그래프에 raw 핑(회색)·EWMA α=0.2(파랑)·140/110 임계 점선과 naive vs hyst 상태 띠, toggles 수를 9초 동안 그려줘.

라이브 데모 열기 — 연결 품질 HUD · 히스테리시스