따알깍PROMPT DICT 앱으로 열기

장르 문법 · 슈팅 · 격투 · 아케이드 · 스포츠 · 격투 게임

격투 게임 기술 구현 Fighting game technical implementation

1 대 1 옆모습 격투 게임을 실제로 만든다고 보고, 엔진 코드가 정해야 하는 것을 모았습니다. 한 틱의 처리 순서, 방향 입력 정리, 버튼 버퍼, 밀림 상자, 판정 상자 반전, 경직 카운터, 표에서 계산하는 유불리, 콤보 보정, 잡기와 타격 동시 판정, 고정소수 좌표, 상태 스냅숏, 리플레이 파일을 프레임 숫자로 정합니다. 모든 카드는 대전 장면 옆에 실시간 데이터 패널이 함께 흐릅니다.

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

카드 목록 40개
  1. 한 틱 처리 순서 (입력 → 상태 → 이동 → 밀림 → 판정 · 판정을 이동 앞에 두면 1f 늦게 맞는다)
  2. SOCD 정리 뒤 숫자 표기 (절대 좌우에서 ←+→ = 중립 · ↑+↓ = ↑ · 그다음 바라보는 쪽으로 4 ↔ 6)
  3. 버튼 버퍼 4f는 누른 엣지만 (후딜 끝 3f 전 누름 → 첫 행동 프레임에 발동 · 6f 전은 버림 · 꾹 누르기는 안 나감)
  4. 방향 갱신 규칙 (지상 · 행동 가능이면 중심이 넘어간 틱에 · 공중은 착지 틱에 · 가드 방향은 공격자 x로)
  5. 몸 밀림 상자 해결 (겹침을 반씩 나눔 · 벽에 막힌 몫은 상대가 전부 · 걸어 밀면 둘 다 1.6 px/f)
  6. 판정 상자 좌우 반전 (원점 = 발 중심 · x′ = −(x + w) · −x만 하면 상자가 몸 안으로 26 px 밀린다)
  7. 히트스톱 중 모션 창 (12f 창은 정지 11f를 빼고 센다 · 실제 틱으로 세면 정지 중에 넣은 236이 실패)
  8. 경직 카운터 오프바이원 (경직 12 = 행동 불가 12틱 · 검사 뒤 감소 · 감소 뒤 검사면 11틱 → +5가 +4)
  9. 유리 프레임은 표에서 계산 (가드 = 가드경직 − (남은 지속 + 후딜) · 지속 늦게 맞으면 +1씩)
  10. 발생 프레임 표기 규칙 (발생 = 첫 지속 프레임 번호 = 준비 칸 + 1 · 그대로 쓰면 모든 표가 1f 어긋남)
  11. 콤보 대미지 계산 순서 (타 번호로 보정 조회 → 타마다 내림 · 경직이 끝난 틱에 번호 0 · 6타 3,500 → 2,480)
  12. 저글 vs 공중 리셋 (발사기 적중 = 저글 · 몸 판정 켬 / 일반기 공중 적중 = 리셋 · 착지까지 판정 끔 · 착지 4f)
  13. 잡기 vs 타격 같은 틱 판정 (잡기 먼저 · 같은 틱 잽은 무시 · 먼저 지속된 잽은 승 · 잡기끼리는 둘 다 풀림)
  14. 장풍 개체 관리 (주인이 맞아도 계속 · 주인당 1칸 · 화면 끝이나 적중 시 그 틱에 비움)
  15. 좌표 단위 1/1000 px 정수 (걷기 3.2 px/f = 3200 정확 · 1/256 고정소수면 600f에 0.47 px 오차)
  16. 상태 스냅숏 312바이트 (캐릭터 2 × 108 + 장풍 80 + 경기 16 · 포인터 없는 한 덩어리 · 롤백 링 8칸)
  17. 트레이닝 프레임 미터 (실제 상태를 기록 · 히트스톱 칸은 건너뜀 · 그래야 LP 11칸 · 유리 +1 · 빈틈 5f)
  18. 응징 AI는 프레임 표를 읽는다 (발생 ≤ −유리 · 사거리 ≥ 거리 · 그중 대미지 최대 · MP −2는 불가 · HP −5는 2LK)
  19. 리플레이 파일 = 머리 16 B + 입력 (1틱 2 B · 같은 입력은 줄 단위 3 B · 3라운드 71 KB → 약 13 KB)
  20. 라운드 타이머 (남은 프레임 정수 5,940 · 표시 = 60으로 나눠 올림 · 소개 · 암전 · KO 중엔 정지)
  21. 장풍끼리 먼저 판정 (틱마다 ① 장풍 × 장풍 전부 → ② 장풍 × 몸 · 슬롯 순서 한 번에 돌리면 0번 슬롯이 이긴다)
  22. 공중 밀림 상자는 가로로만 (z < 80일 때 x 겹침만 반씩 · 보통 AABB 짧은 축 해결은 머리 위에 세운다)
  23. 마지막 틱은 KO가 먼저 (판정 → 적용 → KO 판정 → 그다음 타이머 −1 · 타이머를 먼저 줄이면 마지막 틱 적중이 버려져 타임 오버 패배)
  24. 롤백 중 이펙트 · 소리는 키 장부로 (키 = 틱 · 공격자 · 기술 · 결과 · 재시뮬에 같은 키면 새로 안 만들고 없어진 키는 3f에 지운다)
  25. KO 연출은 확정 틱 뒤에 (시뮬은 바로 KO · 아나운서 · 라운드 끝은 확정 ≥ KO 틱 · KO 정지 40f > 최대 롤백 8f)
  26. 오프라인은 vblank마다 1틱 (60 Hz 누적기를 59.94 Hz 화면에 쓰면 999프레임마다 2틱 · 60.05 Hz면 1,201프레임마다 0틱 · 잠그면 라운드가 99.10 s)
  27. CPU도 가상 패드로 입력 (AI는 2 B 입력 단어만 쓴다 → SOCD · 버퍼 · 모션 판정을 사람과 똑같이 지남 · 리플레이에도 남는다)
  28. 판정 데이터는 구간 + 린트 (로드 때 프레임 배열로 컴파일 · 판정 = 발생 ~ 발생 + 지속 − 1 · 모든 프레임에 피격 상자 · 끝 = 전체 길이)
  29. 키 설정은 SOCD 앞 한 층 (기기 버튼 → 논리 LP…HK · 단축 버튼 = 같은 틱 엣지 2개 · 리플레이 · 넷코드는 논리 단어만)
  30. 판정은 상태 프레임 스크립트로 (f10 hit on · f14 hit off · 애니 이벤트 0.150 s에 묶으면 50 fps에서 11틱 · 재시뮬에선 안 생김)
  31. 더미 녹화는 앞 · 뒤 기준 (숫자 표기 6 = 앞으로 저장 · 재생 때 지금 방향을 곱함 · 절대 ←로 저장하면 사이드 바꾼 뒤 대시가 백대시)
  32. 잡기 착지점은 시작 틱에 계산 (뒤 던지기 = 공격자 − 60 px · 벽 밖으로 넘친 55 px는 30f 동안 공격자를 민다 · 끝에 놓고 맞추면 25 px 튕김)
  33. 라운드 사이 초기화 목록 (FIGHT 틱에 버퍼 · 입력 이력 · 경직 · 장풍 비움 · 게이지 · 승수 · 난수는 유지 · 버퍼를 남기면 FIGHT +1틱 장풍)
  34. KO 슬로는 틱을 건너뛴다 (×0.25 = 화면 4프레임에 시뮬 1틱 · 화면만 보간 · dt × 0.25로 돌리면 같은 띄우기가 2.4 px 더 높다)
  35. 가드 경직 중엔 가드 유지 (←는 행동 가능할 때만 읽음 · 경직 중 ↓만 높이를 바꿈 · 맞을 때마다 ← 확인하면 갭 0 연타가 맞는다)
  36. 점프 궤도는 프레임 표 (y[f] 정수 39칸 · 정점 96 @ f19 · 착지 f38 정확 · 반올림한 v0 10.1 · g 0.53 오일러는 101.3 · f40)
  37. 슬롯 바꿔 돌리기 테스트 (녹화 대전을 P1 · P2 슬롯 번호만 바꿔 다시 실행 · 틱마다 상태가 같아야 함 · 다르면 그 틱이 1P 편향)
  38. 프레임 표는 측정해서 만든다 (헤드리스 테스트가 첫 적중 · 양쪽 행동 가능 틱을 재서 표 생성 · 위키 표와 다르면 CI 실패)
  39. 타격 등급 표 하나로 (기술은 L · M · H만 고르고 정지 8 · 11 · 13 · 경직 12 · 15 · 18 · 밀림 · 스파크는 등급 행에서 · 예외는 덮어쓰기 목록)
  40. 싱크 테스트 (매 틱 저장 → 진행 → 해시 A · 불러오기 → 진행 → 해시 B · 다르면 멈추고 필드 비교 · 스냅숏 밖 전역 변수를 찾는다)

한 틱 처리 순서 (입력 → 상태 → 이동 → 밀림 → 판정 · 판정을 이동 앞에 두면 1f 늦게 맞는다)

Per-tick update order for a fighter: read input, advance state, move, resolve pushboxes, then test hits — testing before movement lands hits one frame late

  • C++
  • C#
  • Unity

60 Hz 한 틱 안에서 입력 읽기, 상태 프레임 +1, 이동, 밀림 상자 해결, 타격 판정, 피격 적용, 방향 갱신을 이 순서로 고정합니다. 판정을 이동보다 먼저 하면 지난 틱 위치로 겹침을 검사해서 3.2 px/f로 걸어오는 상대를 잽이 tick 4가 아니라 tick 5에 맞히고, 유리 프레임이 표의 +5가 아닌 +6이 됩니다. 순서는 엔진 한 곳에서만 정하고 두 캐릭터가 각 단계를 함께 지나가게 합니다.

프롬프트

격투 게임 고정 틱(60 Hz) 루프를 입력 → 상태 진행 → 이동 → 밀림 상자 → 타격 판정 → 적용 → 방향 갱신 순서로 짜고, 두 캐릭터가 각 단계를 함께 지나가게 해 줘. 잽(발생 4 · 지속 2 · 후딜 6, 판정 거리 55 px)과 66.2 px 밖에서 3.2 px/f로 걸어오는 상대로 맞는 순서는 tick 4, 판정을 이동 앞에 둔 순서는 tick 5에 맞는 것을 두 줄로 비교하고, 왼쪽 단계 목록을 슬로 모션으로 하나씩 켜 줘.

라이브 데모 열기 — 한 틱 처리 순서 (입력 → 상태 → 이동 → 밀림 → 판정 · 판정을 이동 앞에 두면 1f 늦게 맞는다)

SOCD 정리 뒤 숫자 표기 (절대 좌우에서 ←+→ = 중립 · ↑+↓ = ↑ · 그다음 바라보는 쪽으로 4 ↔ 6)

Input pipeline: SOCD cleaning on absolute left/right first (L+R = neutral, U+D = up), then numpad notation relative to facing

  • C++
  • C#
  • Godot

레버리스 컨트롤러는 ←와 →를 동시에 누를 수 있어서, 원본 입력을 절대 좌우 기준으로 먼저 정리합니다(←+→ = 중립, ↑+↓ = ↑). 그다음 바라보는 방향을 곱해 숫자 표기(6 = 앞, 4 = 뒤 · 가드, 1 = 앉아 가드)로 바꾸면 1P와 2P가 같은 규칙으로 처리됩니다. 모션 해석기와 가드 판정은 이 숫자 표기만 읽으므로 좌우 반전 코드가 한 곳에만 남습니다.

프롬프트

원본 방향 비트(L R U D)를 매 틱 읽어 절대 좌우 기준으로 ←+→는 중립, ↑+↓는 ↑로 정리한 뒤, 숫자 표기 = 5 + dx × 방향 + (↑ 3 · ↓ −3)으로 바꾸는 입력 단계를 만들어 줘. 오른쪽을 보는 1P와 왼쪽을 보는 2P가 누른 키에 따라 6 · 4 · 5 · 6 · 2 · 8 · 4 · 1이 나오는 4단계 예시를 키 그림 → 정리 → 숫자로 보여 주고 캐릭터가 걷기 · 앉기 · 점프로 반응하게 해 줘.

라이브 데모 열기 — SOCD 정리 뒤 숫자 표기 (절대 좌우에서 ←+→ = 중립 · ↑+↓ = ↑ · 그다음 바라보는 쪽으로 4 ↔ 6)

버튼 버퍼 4f는 누른 엣지만 (후딜 끝 3f 전 누름 → 첫 행동 프레임에 발동 · 6f 전은 버림 · 꾹 누르기는 안 나감)

Button buffer of press edges with a 4-frame lifetime: a press 3 f before recovery ends fires on the first actionable frame, 6 f early expires, a held button never re-triggers

  • C#
  • Unity
  • C++

버튼 버퍼는 누른 순간(엣지)과 그 나이만 기억하고 4프레임이 지나면 버립니다. 헛친 MP의 후딜이 21f에 끝날 때 19f에 누른 HP는 22f에 바로 나가고, 16f에 누른 HP는 20f에 버려져 아무것도 나가지 않습니다. 버튼이 눌려 있는지(레벨)로 버퍼를 채우면 꾹 누르고 있던 LP가 행동 가능 프레임마다 저절로 나가므로 엣지만 씁니다.

프롬프트

버튼 6개마다 마지막 누름 엣지의 프레임을 저장하고 나이가 4f 미만일 때만 행동 가능 프레임에 소비하는 버퍼를 만들어 줘. 헛친 MP(발생 7 · 지속 3 · 후딜 12, 첫 행동 22f) 동안 19f 누름 → 22f HP 발동, 16f 누름 → 20f 소멸, 12f부터 LP 홀드 → 엣지 없음을 차례로 재생하고, 아래 타임라인에 버퍼 수명 4칸과 버튼별 나이 숫자를 띄워 줘.

라이브 데모 열기 — 버튼 버퍼 4f는 누른 엣지만 (후딜 끝 3f 전 누름 → 첫 행동 프레임에 발동 · 6f 전은 버림 · 꾹 누르기는 안 나감)

방향 갱신 규칙 (지상 · 행동 가능이면 중심이 넘어간 틱에 · 공중은 착지 틱에 · 가드 방향은 공격자 x로)

Facing update rules: grounded actionable characters turn on the tick their centres cross, airborne ones on landing, and guard direction is judged from the attacker’s x at the hit tick

  • C#
  • Unity
  • Godot

방향은 아무 때나 뒤집지 않고, 땅에 서 있고 행동 가능한 캐릭터만 두 중심이 넘어간 그 틱에 바꿉니다. 점프 중인 캐릭터는 착지 틱까지 처음 방향을 유지해서, 넘어가며 내려치는 공격이 상대의 등 뒤를 맞힙니다. 가드 성공 여부는 맞는 쪽의 방향 값이 아니라 그 틱 공격자 x의 반대쪽을 눌렀는지로 판정합니다.

프롬프트

두 캐릭터의 방향 갱신을 상태별로 나눠 줘: 지상 · 행동 가능이면 상대 중심이 내 중심을 넘은 틱에 즉시, 공중이면 착지 틱에, 경직 중이면 풀린 틱에. 60 px 왼쪽에서 2.6 px/f로 앞 점프(사전 4f · 체공 38f · 정점 96 px)한 1P가 tick 28에 중심을 넘고 tick 35에 P2 + 20.6 px에서 크로스업으로 맞히는 장면에, 틱별 방향 화살표 두 줄과 히트스톱 11f, 착지 tick 53의 방향 전환을 표시해 줘.

라이브 데모 열기 — 방향 갱신 규칙 (지상 · 행동 가능이면 중심이 넘어간 틱에 · 공중은 착지 틱에 · 가드 방향은 공격자 x로)

몸 밀림 상자 해결 (겹침을 반씩 나눔 · 벽에 막힌 몫은 상대가 전부 · 걸어 밀면 둘 다 1.6 px/f)

Body pushbox resolution: split the overlap half and half and hand any wall excess to the other body — walking into an idle opponent moves both at 1.6 px/f, in the corner the walker stops

  • C++
  • C#
  • Unity

이동이 끝난 뒤 두 몸 상자(폭 30 px)의 겹침을 계산해 양쪽으로 절반씩 밀어냅니다. 3.2 px/f로 걸어 들어가면 둘이 1.6 px/f로 함께 밀려가고, 상대가 구석 벽에 붙어 있으면 벽을 넘친 몫을 걷는 쪽에 돌려줘 걷는 쪽이 그 자리에 멈춥니다. 공격 넉백과 별개인 몸끼리의 규칙이라 매 틱 이동 단계 바로 뒤에 한 번만 돌립니다.

프롬프트

매 틱 이동 뒤 ov = 30 − (x2 − x1)이 양수면 x1 −= ov/2, x2 += ov/2로 나누고, x2 + 15가 벽을 넘으면 넘친 e만큼 x2와 x1을 같이 되돌리는 밀림 해결을 만들어 줘. 화면 가운데(둘 다 1.6 px/f)와 구석(걷는 쪽 0 px/f) 두 줄을 같은 걷기 3.2 px/f로 52틱 돌리고, 오른쪽 패널에 겹침 · 반 · 벽 초과 값을 실시간으로 띄워 줘.

라이브 데모 열기 — 몸 밀림 상자 해결 (겹침을 반씩 나눔 · 벽에 막힌 몫은 상대가 전부 · 걸어 밀면 둘 다 1.6 px/f)

판정 상자 좌우 반전 (원점 = 발 중심 · x′ = −(x + w) · −x만 하면 상자가 몸 안으로 26 px 밀린다)

Mirroring hit and hurt boxes for the left-facing side: with the origin at the feet centre use x′ = −(x + w); negating x alone slides the box w pixels into the body

  • C#
  • Unity
  • Godot

판정 상자는 오른쪽을 보는 자세로 발 중심 원점 기준 {x, y, w, h}로 한 번만 작성하고, 왼쪽을 볼 때 x′ = −(x + w)로 뒤집습니다. x만 음수로 바꾸면 LP 상자(x 14, w 26)가 −40..−14가 아니라 −14..12로 가서 자기 몸 안에서 헛칩니다. 몸 상자처럼 원점에 대칭인 상자는 두 식의 결과가 같아 버그가 숨으므로 비대칭 공격 상자로 테스트합니다.

프롬프트

공격 · 몸 상자를 오른쪽 기준 {x, y, w, h}(원점 = 발 중심)로 저장하고 facing < 0이면 x′ = −(x + w)로 반전하는 함수를 만들어 줘. 마주 선 두 캐릭터 중 2P가 LP {x:14, y:52, w:26, h:10}를 칠 때 맞는 식(−40..−14, 적중)과 −x만 한 식(−14..12, 자기 몸 안)을 2.7초씩 번갈아 보여 주고, 아래 −50..50 눈금자와 오른쪽 코드 패널을 함께 그려 줘.

라이브 데모 열기 — 판정 상자 좌우 반전 (원점 = 발 중심 · x′ = −(x + w) · −x만 하면 상자가 몸 안으로 26 px 밀린다)

히트스톱 중 모션 창 (12f 창은 정지 11f를 빼고 센다 · 실제 틱으로 세면 정지 중에 넣은 236이 실패)

Motion-input windows across hitstop: count the 12-frame window in simulation frames so the 11 frozen frames do not eat a 236 entered across the freeze

  • C++
  • C#
  • Unity

MP가 맞으면 두 캐릭터가 11f 멈추고 그동안에도 입력은 계속 기록됩니다. 236 + P를 정지 앞뒤에 걸쳐 넣으면(2는 적중 4틱 전, P는 12틱 뒤) 실제 틱으로는 16틱이라 12f 창을 넘어 실패하지만, 정지 프레임을 빼고 세면 5f라 캔슬이 성립합니다. 입력 기록 한 칸마다 정지 중 여부를 같이 저장하고 창은 정지가 아닌 칸만 셉니다.

프롬프트

입력 기록 링에 칸마다 frozen 플래그를 함께 저장하고, 모션 해석기의 12f 창은 frozen이 아닌 칸만 세게 만들어 줘. MP 적중(히트스톱 11f, tick 1–11) 주변에서 2 @−4 · 3 @4 · 6 @9 · P @12를 넣을 때 실제 틱 창(1–12, 실패 → MP 후딜)과 시뮬 프레임 창(성립 → 236P 캔슬 · 장풍)을 한 번씩 재생하고, 타임라인에 정지 구간과 두 창을 칠해 줘.

라이브 데모 열기 — 히트스톱 중 모션 창 (12f 창은 정지 11f를 빼고 센다 · 실제 틱으로 세면 정지 중에 넣은 236이 실패)

경직 카운터 오프바이원 (경직 12 = 행동 불가 12틱 · 검사 뒤 감소 · 감소 뒤 검사면 11틱 → +5가 +4)

Stun counter off-by-one: check-then-decrement gives exactly N non-actionable frames; decrement-then-check loses one, so a +5 move measures +4

  • C++
  • C#
  • Unity

경직 12는 상대가 정확히 12틱 동안 행동하지 못한다는 뜻이어야 기술 표의 유리 프레임이 맞습니다. "stun--; 0 이하면 행동" 순서는 카운터를 넣은 틱 다음부터 11틱만 묶어 LP 적중이 +4가 되고, "0보다 크면 감소하고 경직, 아니면 행동" 순서는 12틱을 묶어 표의 +5와 같습니다. 경직 · 히트스톱 · 무적 타이머를 모두 같은 한 가지 규칙으로 통일합니다.

프롬프트

LP(발생 4 · 지속 2 · 후딜 6)가 4f에 맞혀 경직 12를 넣을 때, 감소 후 검사(stun--; if (stun <= 0) 행동)와 검사 후 감소(if (stun > 0) { stun--; 경직 } else 행동)를 두 줄 프레임 미터로 비교해 줘. 칸마다 남은 카운터 숫자를 쓰고 P2 행동 프레임 16 vs 17, 유리 +4 vs +5를 마지막에 띄워 줘.

라이브 데모 열기 — 경직 카운터 오프바이원 (경직 12 = 행동 불가 12틱 · 검사 뒤 감소 · 감소 뒤 검사면 11틱 → +5가 +4)

유리 프레임은 표에서 계산 (가드 = 가드경직 − (남은 지속 + 후딜) · 지속 늦게 맞으면 +1씩)

Frame advantage derived from the move table: on block = block-stun − (remaining active + recovery), one better for every later active frame that connects

  • C#
  • Unity
  • Canvas

유리 프레임은 사람이 표에 손으로 적지 않고 발생 · 지속 · 후딜과 경직 값으로 계산합니다. 첫 지속 프레임에 맞으면 LP 8 − (1 + 6) = +1, MP 12 − (2 + 12) = −2, HP 16 − (3 + 18) = −5로 기획 값과 맞아떨어지고, 지속 마지막 칸에 늦게 맞히면 남은 지속이 줄어 LP가 +2가 됩니다. 히트스톱은 두 캐릭터가 같이 멈추므로 계산에서 뺍니다.

프롬프트

기술 표(발생 · 지속 · 후딜 · 가드경직 · 히트경직)에서 가드 유리 = 가드경직 − (지속 − 맞은 칸 + 후딜), 히트 유리 = 히트경직 − (같은 값)을 계산하는 함수를 만들어 줘. LP 4/2/6(8 · 12), MP 7/3/12(12 · 15), HP 10/4/18(16 · 18), 지속 2칸째에 맞은 LP를 차례로 가드시키며 두 줄 프레임 미터의 행동 가능 차이와 +1 · −2 · −5 · +2를 띄워 줘.

라이브 데모 열기 — 유리 프레임은 표에서 계산 (가드 = 가드경직 − (남은 지속 + 후딜) · 지속 늦게 맞으면 +1씩)

발생 프레임 표기 규칙 (발생 = 첫 지속 프레임 번호 = 준비 칸 + 1 · 그대로 쓰면 모든 표가 1f 어긋남)

Startup notation: export startup as the number of the first active frame (pre-active frames + 1), not the raw count of startup frames

  • C#
  • Unity
  • Canvas

기술 데이터는 준비 3 · 지속 2 · 후딜 6처럼 칸 수로 저장되지만, 화면과 공략에 보이는 발생은 첫 판정이 나오는 프레임 번호(4f)입니다. 내보내는 단계에서 준비 + 1로 바꿔야 LP 4f · MP 7f · HP 10f · 앉아 약발 하단 5f가 기획서와 같아지고, 유리 계산식도 같은 기준을 씁니다. 준비 칸 수를 그대로 내보내면 4f 잽이 3f로 보여 확정 반격 표가 전부 1f씩 틀립니다.

프롬프트

내부 기술 표 {준비, 지속, 후딜}을 화면용 프레임 데이터 {발생 = 준비 + 1, 지속, 후딜, 전체 = 준비 + 지속 + 후딜}로 내보내는 함수를 만들어 줘. LP(3 · 2 · 6)의 12칸 프레임 미터에 칸 번호를 쓰고 준비 1–3 · 지속 4–5 · 후딜 6–11 · 12 행동을 괄호로 묶은 뒤, LP · MP · HP · 2LK의 내부 값 3 · 6 · 9 · 4와 표기 값 4 · 7 · 10 · 5를 나란히 보여 줘.

라이브 데모 열기 — 발생 프레임 표기 규칙 (발생 = 첫 지속 프레임 번호 = 준비 칸 + 1 · 그대로 쓰면 모든 표가 1f 어긋남)

콤보 대미지 계산 순서 (타 번호로 보정 조회 → 타마다 내림 · 경직이 끝난 틱에 번호 0 · 6타 3,500 → 2,480)

Combo damage pipeline: look up the scaling step by hit index, floor each hit, and zero the index on the first actionable tick (six hits: 3,500 → 2,480)

  • C#
  • Unity
  • C++

콤보 대미지는 합계에 한 번 곱하지 않고, 타마다 그 타의 번호로 보정 표(100 · 100 · 80 · 70 · 60 · 50 … 최저 20 %)를 찾아 곱한 뒤 내림합니다. 그래서 2LK · 2LP · MP · HP · 236P 2타의 기본 3,500이 300 · 300 · 480 · 630 · 420 · 350, 합계 2,480이 됩니다. 번호는 맞는 쪽 경직이 이어지는 동안만 올라가고 행동 가능한 첫 틱에 0이 되므로, 경직이 풀린 뒤 다시 맞힌 잽은 100 %로 들어갑니다.

프롬프트

피격 처리에서 hitIndex로 보정 표 [100, 100, 80, 70, 60, 50, 40, 30, 20]을 찾아 대미지 = floor(기본 × 보정 / 100)을 타마다 계산하고, hitIndex는 경직 중 피격일 때 +1, 행동 가능해진 틱에 0으로 만들어 줘. 300 · 300 · 600 · 900 · 700 · 700 콤보(합계 2,480)를 0.55초 간격으로 재생하며 오른쪽 표 · 아래 기본 대 실제 막대 · 행동 가능 뒤 새 잽 300(100 %)을 함께 보여 줘.

라이브 데모 열기 — 콤보 대미지 계산 순서 (타 번호로 보정 조회 → 타마다 내림 · 경직이 끝난 틱에 번호 0 · 6타 3,500 → 2,480)

저글 vs 공중 리셋 (발사기 적중 = 저글 · 몸 판정 켬 / 일반기 공중 적중 = 리셋 · 착지까지 판정 끔 · 착지 4f)

Juggle state vs air reset: launcher hits keep the airborne body hittable, plain air hits send it into a reset state with no hurtbox until it lands with 4 frames of landing

  • C#
  • Unity
  • Godot

공중에 뜬 상대를 맞혔을 때 기술 표에 launch 플래그가 있으면 저글 상태로 두어 몸 판정을 켠 채 추가타를 허용합니다. 플래그가 없는 공중 잽 같은 일반기는 공중 리셋 상태로 보내 착지할 때까지 몸 판정을 끄고 두 발로 내리게 하며, 착지 4f 뒤 바로 행동하게 합니다. 이 분기가 없으면 공중 잽 한 번이 끝없는 공중 콤보의 시동이 됩니다.

프롬프트

공중 피격 처리에서 기술의 launch 플래그로 분기해 줘: 있으면 JUGGLE(몸 판정 유지 · 추가타 허용 · 착지 = 다운), 없으면 AIR_RESET(몸 판정 끔 · 뒤로 한 바퀴 돌며 낙하 · 착지 4f 후 행동). 대공 발사기 → 추가타 적중과, 공중 잽 → 지상 MP가 몸을 통과하는 두 줄을 4.4초 루프로 보여 주고 오른쪽에 상태 단계를 켜 줘.

라이브 데모 열기 — 저글 vs 공중 리셋 (발사기 적중 = 저글 · 몸 판정 켬 / 일반기 공중 적중 = 리셋 · 착지까지 판정 끔 · 착지 4f)

잡기 vs 타격 같은 틱 판정 (잡기 먼저 · 같은 틱 잽은 무시 · 먼저 지속된 잽은 승 · 잡기끼리는 둘 다 풀림)

Same-tick throw vs strike resolution: resolve throws before strikes, so a throw beats a jab that becomes active on the same tick, loses to one already active, and two throws tech each other

  • C++
  • C#
  • Unity

한 틱에 잡기와 타격이 같이 성립하면 잡기를 먼저 처리하고, 잡힌 쪽의 같은 틱 타격은 버립니다. 상대 잽이 그보다 먼저 지속에 들어가 잡기 발생(7f) 중인 몸을 맞혔다면 이미 피격 상태라 잡기가 취소되고, 둘 다 같은 틱에 잡기를 내밀면 자동으로 풀려 서로 튕겨 나갑니다. 순서를 표로 고정해야 롤백 재시뮬에서도 같은 결과가 나옵니다.

프롬프트

판정 단계를 잡기 → 타격 순으로 나눠 줘: 같은 틱에 잡기가 성립하면 잡힌 쪽 공격은 버리고, 양쪽 잡기면 둘 다 풀기(40 px씩 튕김), 이미 피격 중이면 잡기 취소. 잡기(발생 7f · 거리 40 px)를 상대가 가만히 · 같은 틱 잽 · 2틱에 누른 잽(5틱 지속) · 같은 틱 잡기로 받는 4줄을 동시에 재생하고 오른쪽에 결과 태그를 띄워 줘.

라이브 데모 열기 — 잡기 vs 타격 같은 틱 판정 (잡기 먼저 · 같은 틱 잽은 무시 · 먼저 지속된 잽은 승 · 잡기끼리는 둘 다 풀림)

장풍 개체 관리 (주인이 맞아도 계속 · 주인당 1칸 · 화면 끝이나 적중 시 그 틱에 비움)

Projectile entities: independent of the owner’s state, one slot per owner, freed on the tick they leave the camera or spend their last hit

  • C#
  • Unity
  • Godot

장풍은 캐릭터 상태에 붙은 그림이 아니라 주인 · 위치 · 속도 · 남은 히트 · 나이를 가진 별도 개체로 매 틱 움직입니다. 주인이 점프 공격에 맞아도 날아가던 장풍은 그대로 가고, 주인당 슬롯이 1칸이라 슬롯이 차 있는 동안 236P는 거부되어 P만 LP로 나갑니다. 화면 끝을 넘거나 히트가 0이 되는 그 틱에 슬롯을 비우면 바로 다음 장풍을 쏠 수 있습니다.

프롬프트

장풍을 {주인, x, vx, 히트, 나이, 상태} 개체 배열(캐릭터당 1칸)로 관리하고 캐릭터 상태와 무관하게 매 틱 이동시켜 줘. 1P가 tick 0에 236P(발생 12f, 6 px/f)를 쏘고, 점프로 넘어온 2P에게 tick 51에 맞아도 장풍이 계속 가며, tick 74의 236P는 슬롯이 차서 LP로 바뀌고, 화면 끝 tick 86에 비운 뒤 다시 쏜 장풍이 2P를 맞히고 사라지는 흐름과 아래 슬롯 표를 보여 줘.

라이브 데모 열기 — 장풍 개체 관리 (주인이 맞아도 계속 · 주인당 1칸 · 화면 끝이나 적중 시 그 틱에 비움)

좌표 단위 1/1000 px 정수 (걷기 3.2 px/f = 3200 정확 · 1/256 고정소수면 600f에 0.47 px 오차)

Position units for a deterministic fighter: integer 1/1000-pixel coordinates keep 3.2 px/f exact, while Q8 (1/256) rounds it to 3.1992 and drifts 0.47 px in 600 frames

  • C++
  • C#
  • Unity

롤백과 리플레이가 비트 단위로 같으려면 위치와 속도를 float가 아닌 정수로 저장하는데, 단위를 무엇으로 정하느냐에 따라 기획 숫자가 지켜지기도 깨지기도 합니다. 1/256 단위(Q8)로는 3.2 px/f가 819/256 = 3.1992로 깎여 600f 걷기에서 0.469 px 짧고, 뒤 걷기 2.6은 666/256으로 올라가 0.938 px 길어집니다. 1/1000 px 정수로 두면 3200 · 2600이 정확해 표의 숫자와 화면이 같습니다.

프롬프트

캐릭터 좌표와 속도를 1/1000 px 단위 int32로 저장하는 이동 코드를 만들고, 비교용으로 Q8(1/256) 고정소수 판을 나란히 둬 줘. 3.2 px/f로 600f를 걸을 때 1920.000 vs 1919.531, 뒤 2.6 px/f는 1560 vs 1560.938이 되는 것을 두 줄 활주로와 ±1 px를 24배 확대한 돋보기로 보여 줘.

라이브 데모 열기 — 좌표 단위 1/1000 px 정수 (걷기 3.2 px/f = 3200 정확 · 1/256 고정소수면 600f에 0.47 px 오차)

상태 스냅숏 312바이트 (캐릭터 2 × 108 + 장풍 80 + 경기 16 · 포인터 없는 한 덩어리 · 롤백 링 8칸)

Game-state snapshot layout: one pointer-free 312-byte block (2 × 108 B fighters, 80 B projectiles, 16 B match) copied into an 8-slot rollback ring every tick

  • C++
  • C#
  • Unity

롤백 저장 · 불러오기를 매 틱 하려면 게임 상태를 포인터 없는 구조체 하나로 모아 memcpy 한 번으로 복사해야 합니다. 캐릭터 1명은 위치 · 속도 · 상태 · 경직 · 버튼 버퍼 · 32f 입력 이력까지 108바이트, 장풍 4칸 80바이트, 프레임 · 타이머 · 난수 · 카메라 16바이트로 모두 312바이트이고 8칸 링이어도 2,496바이트입니다. 스프라이트 · 파티클 · 소리 같은 연출은 스냅숏에 넣지 않고 상태에서 다시 만듭니다.

프롬프트

격투 게임 상태를 포인터 없는 구조체(캐릭터 2 × 108 B, 장풍 4 × 20 B, 경기 16 B = 312 B)로 정의하고 매 틱 8칸 링 버퍼에 memcpy로 저장하게 해 줘. 오른쪽에 필드별 바이트 막대, 아래에 slot 0–7과 프레임 번호를 그리고, 3틱 늦은 입력이 오면 해당 칸을 불러와 3틱 재시뮬하는 장면을 보여 줘.

라이브 데모 열기 — 상태 스냅숏 312바이트 (캐릭터 2 × 108 + 장풍 80 + 경기 16 · 포인터 없는 한 덩어리 · 롤백 링 8칸)

트레이닝 프레임 미터 (실제 상태를 기록 · 히트스톱 칸은 건너뜀 · 그래야 LP 11칸 · 유리 +1 · 빈틈 5f)

Training-mode frame meter built from recorded per-tick state, skipping hitstop frames so cell counts match the move table (LP 11 cells, +1, 5-frame gap)

  • C#
  • Unity
  • Canvas

프레임 미터는 기술 표가 아니라 매 틱 두 캐릭터의 실제 상태(발생 · 지속 · 후딜 · 가드경직 · 행동 가능)를 링 버퍼에 기록해서 그립니다. 히트스톱 칸까지 실시간으로 쌓으면 LP 하나가 18칸으로 보여 칸을 세는 사람이 틀리므로, 정지 중인 틱은 기록하지 않고 건너뜁니다. 그러면 LP 가드 뒤 MP까지 유리 +1, 빈틈 5f가 칸 수로 그대로 읽힙니다.

프롬프트

트레이닝 모드 프레임 미터를 매 틱 두 캐릭터 상태를 120칸 링에 기록해 그리고, 히트스톱 중인 틱은 기록하지 않게 해 줘. LP(4 · 2 · 6) 가드(정지 7f) 직후 MP(7 · 3 · 12, 정지 10f)를 이어 칠 때 정지 포함 줄(LP가 18칸)과 건너뛴 줄(11칸 · 유리 +1 · 빈틈 5f)을 위아래로 비교해 줘.

라이브 데모 열기 — 트레이닝 프레임 미터 (실제 상태를 기록 · 히트스톱 칸은 건너뜀 · 그래야 LP 11칸 · 유리 +1 · 빈틈 5f)

응징 AI는 프레임 표를 읽는다 (발생 ≤ −유리 · 사거리 ≥ 거리 · 그중 대미지 최대 · MP −2는 불가 · HP −5는 2LK)

Punish AI from frame data: after blocking, pick the highest-damage own move whose startup ≤ −advantage and whose reach covers the post-pushback distance

  • C#
  • Unity
  • C++

CPU는 상대 기술을 가드하면 그 기술의 가드 유리와 밀린 뒤 거리를 표에서 읽고, 자기 기술 중 발생이 −유리 이하이고 사거리가 거리 이상인 것만 후보로 남깁니다. MP(−2)는 가장 빠른 기술도 4f라 가드를 유지하고, HP(−5, 거리 58 px)는 LP가 4f지만 사거리 55라 빠지고 2LK(5f · 60 px)가 후딜 마지막 프레임에 정확히 들어갑니다. 난이도는 판단이 아니라 반응 지연 프레임으로만 조절합니다.

프롬프트

AI 응징 함수를 만들어 줘: 가드 후 adv와 dist를 읽고 자기 기술 표에서 startup ≤ −adv && reach ≥ dist인 후보 중 대미지가 가장 큰 것을 고른다. 후보 LP(4f · 55 px · 300), 2LK(5f · 60 px · 250), 623P(5f · 50 px · 1200), MP(7f · 65 px · 600)로 MP 가드(−2 · 50 px → 응징 없음)와 HP 가드(−5 · 58 px → 2LK)를 재생하고, 오른쪽에 ✓ · ✗ 표, 아래에 두 줄 프레임 미터를 그려 줘.

라이브 데모 열기 — 응징 AI는 프레임 표를 읽는다 (발생 ≤ −유리 · 사거리 ≥ 거리 · 그중 대미지 최대 · MP −2는 불가 · HP −5는 2LK)

리플레이 파일 = 머리 16 B + 입력 (1틱 2 B · 같은 입력은 줄 단위 3 B · 3라운드 71 KB → 약 13 KB)

Replay file format: a 16-byte header (build hash, seed, characters, stage, settings) plus 2-byte input words per player per frame, run-length encoded

  • C++
  • C#
  • Unity

결정론적 시뮬이라 리플레이에는 상태가 아니라 빌드 해시 · 난수 시드 · 캐릭터 · 스테이지와 매 틱 입력만 넣습니다. 입력 한 틱은 방향 4비트와 버튼 6비트를 2바이트에 담고, 같은 값이 이어지는 구간을 입력 2 B + 길이 1 B로 묶으면 최대 3라운드 17,820f의 원본 71,280바이트가 평균 줄 길이 8f 기준 약 13,365바이트가 됩니다. 패치로 시뮬이 바뀌면 같은 입력이 다른 경기가 되므로 해시가 다른 파일은 재생을 거부합니다.

프롬프트

리플레이 파일을 머리 16 B(빌드 해시 4 · 시드 4 · 캐릭터 2 · 스테이지 1 · 라운드 수 1 · 입력 지연 1 · 예약 3) + 플레이어별 입력 줄 {값 2 B, 길이 1 B}로 저장하고, 불러올 때 해시가 다르면 거부하게 해 줘. 재생 장면 아래에 최근 44f 입력 테이프를 줄 단위로 묶어 그리고 원본 바이트와 줄 단위 바이트를 실시간으로 세어 줘.

라이브 데모 열기 — 리플레이 파일 = 머리 16 B + 입력 (1틱 2 B · 같은 입력은 줄 단위 3 B · 3라운드 71 KB → 약 13 KB)

라운드 타이머 (남은 프레임 정수 5,940 · 표시 = 60으로 나눠 올림 · 소개 · 암전 · KO 중엔 정지)

Round timer as an integer frame count (99 × 60 = 5,940) displayed as ceil(frames / 60), paused during the intro, super freeze and KO

  • C#
  • Unity
  • Godot

타이머는 초가 아니라 남은 프레임 정수로 시뮬 상태 안에 두고, 화면에는 60으로 나눠 올림한 값을 보여 줍니다. 올림이면 99가 첫 60f 동안 보이고 1은 마지막 60f, 0은 정확히 끝나는 순간이며, 내림이면 시작 1틱 만에 98이 되고 마지막 59f는 0인 채 싸웁니다. 히트스톱 중에는 계속 줄지만 라운드 소개 · 초필살 암전 · KO 연출 동안은 멈춥니다.

프롬프트

라운드 타이머를 int remain = 5940으로 시뮬 상태에 넣고 매 틱 1씩 줄이되 소개 · 암전(45f) · KO 중에는 멈추고, 화면 숫자는 ceil(remain / 60)으로 그려 줘. 시작 90f · 암전이 낀 중반 · 마지막 130f를 이어 재생하며 올림(B)과 내림(A) 표시를 나란히 띄우고, 아래 타임라인에 정지 구간을 보라색으로 칠해 줘.

라이브 데모 열기 — 라운드 타이머 (남은 프레임 정수 5,940 · 표시 = 60으로 나눠 올림 · 소개 · 암전 · KO 중엔 정지)

장풍끼리 먼저 판정 (틱마다 ① 장풍 × 장풍 전부 → ② 장풍 × 몸 · 슬롯 순서 한 번에 돌리면 0번 슬롯이 이긴다)

Two-phase projectile resolution per tick: all projectile-vs-projectile pairs first, then projectile-vs-body, so slot order never decides a clash

  • C++
  • C#
  • Unity

장풍마다 몸 → 상대 장풍 순서로 슬롯 0번부터 한 번에 검사하면, P2가 장풍을 쏜 29틱에 P1 장풍이 P2 몸과 P2 장풍에 동시에 겹칠 때 P1 장풍이 먼저 몸을 맞혀 사라지고 P2 장풍은 짝을 잃고 날아가 58틱에 P1까지 맞힙니다. 같은 장면에서 P2가 0번 슬롯이었다면 상쇄로 끝나므로 결과가 1P · 2P 자리에 따라 바뀝니다. 장풍끼리 겹침을 모든 슬롯에 대해 먼저 처리하고, 남은 장풍만 몸과 검사하면 순서와 무관하게 상쇄됩니다.

프롬프트

투사체 판정을 매 틱 ① 모든 장풍 쌍의 겹침(판정 16 px) → 상쇄 ② 남은 장풍 × 상대 몸(30 px) 두 단계로 나눠 줘. 4 px/f로 날아가는 P1 장풍이 160 px 떨어진 P2 몸에 닿는 29틱에 P2가 136에 장풍을 내는 장면을 A(슬롯 순서대로 한 번에: P2 29틱 · P1 58틱 피격)와 B(두 단계: 29틱 상쇄)로 나란히 재생하고, 오른쪽 패널에 그 틱의 처리 순서를 줄마다 켜 줘.

라이브 데모 열기 — 장풍끼리 먼저 판정 (틱마다 ① 장풍 × 장풍 전부 → ② 장풍 × 몸 · 슬롯 순서 한 번에 돌리면 0번 슬롯이 이긴다)

공중 밀림 상자는 가로로만 (z < 80일 때 x 겹침만 반씩 · 보통 AABB 짧은 축 해결은 머리 위에 세운다)

Airborne pushbox resolution on the x axis only; a generic minimum-penetration AABB solve parks a jumper on the opponent's head and drops it behind

  • C++
  • C#
  • Godot

앞점프(2.4 px/f · 공중 38f · 정점 96)로 80 px 앞 상대에게 떨어지면 27번째 공중 프레임에 높이 79로 처음 겹치는데, 관통이 x 14.8 · y 1.0이라 플랫포머식 짧은 축 해결은 위로 밀어 올려 상대 머리 위(z 80)에 세웁니다. 그대로 미끄러지다 뒤로 떨어져 67틱에 착지하면 사이드까지 바뀝니다. 격투 게임 밀림은 높이가 상대 상자 안일 때 x만 반씩 밀어서 42틱에 간격 30으로 앞에 내려앉게 하고, 사이드는 중심이 넘어갔을 때만 바뀝니다.

프롬프트

밀림 상자를 30 × 80으로 두고 공중 캐릭터의 발 높이 z가 80보다 낮을 때만 x 관통을 두 사람에게 반씩 나눠 미는 규칙을 만들어 줘. 80 px 앞에 선 상대에게 2.4 px/f 앞점프(준비 4f · 공중 38f · 높이 표 96·4f(38−f)/38²)로 떨어지는 장면을 왼쪽 A(짧은 축 AABB → 31틱에 머리 위, 67틱 뒤로 착지 · 사이드 바뀜)와 오른쪽 B(가로만 → 42틱 앞 착지 · 간격 30)로 나란히 보여 주고, 아래 패널에 z · x 차 · 첫 겹침 관통량을 실시간으로 띄워 줘.

라이브 데모 열기 — 공중 밀림 상자는 가로로만 (z < 80일 때 x 겹침만 반씩 · 보통 AABB 짧은 축 해결은 머리 위에 세운다)

마지막 틱은 KO가 먼저 (판정 → 적용 → KO 판정 → 그다음 타이머 −1 · 타이머를 먼저 줄이면 마지막 틱 적중이 버려져 타임 오버 패배)

Last-tick ordering of KO versus time over: resolve hits, apply damage and judge KO before the timer step, so a hit on the final tick wins by KO instead of being discarded

  • C#
  • Unity
  • C++

남은 시간이 1f일 때 체력 300인 P1의 MP(600)가 체력 500인 P2에게 마지막 틱에 맞으면, 틱 첫머리에서 타이머를 줄이는 코드는 0이 되는 순간 라운드를 끝내 판정을 건너뛰고 체력 비교로 P2에게 승리를 줍니다. 판정 · 적용 · KO 판정을 마친 뒤 타이머를 줄이면 같은 틱에 P2가 0이 되어 P1의 KO 승으로 끝납니다. 화면 숫자는 이미 0을 향해 가고 있으므로 이 순서를 정해 두지 않으면 마지막 순간의 역전이 버그처럼 보입니다.

프롬프트

라운드 틱 순서를 입력 → 상태 → 이동 → 밀림 → 판정 → 적용 → KO 판정 → 타이머 −1 → 0이면 타임 오버(체력 비교)로 고정해 줘. 남은 12f에서 P1(체력 300)이 6틱에 MP(발생 7, 600)를 눌러 마지막 12틱에 P2(체력 500)에게 맞는 장면을 두 번 재생해 A(타이머 먼저: TIME OVER · P2 승)와 B(KO 먼저: K.O. · P1 승)를 아래 두 패널의 순서 목록과 함께 보여 주고, 위에 ceil(남은 프레임 / 60) 타이머와 남은 프레임을 띄워 줘.

라이브 데모 열기 — 마지막 틱은 KO가 먼저 (판정 → 적용 → KO 판정 → 그다음 타이머 −1 · 타이머를 먼저 줄이면 마지막 틱 적중이 버려져 타임 오버 패배)

롤백 중 이펙트 · 소리는 키 장부로 (키 = 틱 · 공격자 · 기술 · 결과 · 재시뮬에 같은 키면 새로 안 만들고 없어진 키는 3f에 지운다)

Rollback-safe presentation events: sparks and sounds are spawned through a ledger keyed by tick, attacker, move and result, so re-simulation neither duplicates nor leaves stale effects

  • C++
  • C#
  • Unreal

롤백 넷코드에서 재시뮬 도중 시뮬 코드가 스파크와 소리를 직접 만들면, 104틱에 97–100 실제 입력이 도착해 다시 계산할 때 100틱 타격 스파크와 타격음이 한 번 더 생기고 난수도 달라져 모양까지 바뀝니다. 실제로는 가드였던 경우엔 타격 스파크가 남은 채 가드 스파크가 겹칩니다. 이펙트 요청을 (틱 · 공격자 · 기술 · 결과) 키로 장부에 넣어 같은 키는 확정만 하고, 재시뮬에서 다시 나오지 않은 키는 짧게 지우며, 모양 난수는 키의 해시로 정합니다.

프롬프트

시뮬은 이펙트를 직접 만들지 말고 fxRequest(tick, attacker, move, result)만 내게 하고, 표시 쪽 장부가 같은 키는 무시 · 새 키는 생성(나이 = 현재 − tick) · 재시뮬 뒤 사라진 키는 3f 페이드로 지우게 해 줘. MP(발생 7)가 100틱에 맞고 104틱에 97–100 입력이 도착하는 두 사례(① 실제는 99틱 약P라 결과 같음 ② 실제는 ← 가드)를 A(바로 생성: 스파크 2개 · 소리 2번)와 B(장부)로 나란히 재생하고, 아래에 틱 줄 · 되감기 화살표 · 장부 줄을 보여 줘.

라이브 데모 열기 — 롤백 중 이펙트 · 소리는 키 장부로 (키 = 틱 · 공격자 · 기술 · 결과 · 재시뮬에 같은 키면 새로 안 만들고 없어진 키는 3f에 지운다)

KO 연출은 확정 틱 뒤에 (시뮬은 바로 KO · 아나운서 · 라운드 끝은 확정 ≥ KO 틱 · KO 정지 40f > 최대 롤백 8f)

KO under rollback: the simulation enters KO immediately, but irreversible presentation (announcer, round end, results) waits until the KO tick is confirmed; a 40-frame KO freeze hides the wait

  • C++
  • C#
  • Unreal

롤백 대전에서 예측 입력으로 KO가 났을 때 바로 "K.O." 아나운서와 라운드 종료를 띄우면, 8틱 늦게 도착한 실제 입력이 −3틱 백대시였던 경우 5틱에 되감기가 일어나 이미 외친 KO를 취소해야 합니다. 시뮬 안의 KO 상태는 즉시 들어가되 되돌릴 수 없는 연출만 확정 틱(로컬 − 8)이 KO 틱을 지난 뒤 시작합니다. KO 정지를 40f로 두면 최대 롤백 8f보다 길어서 기다림이 정지 안에 숨어 양쪽 화면이 똑같이 보입니다.

프롬프트

롤백 넷코드에서 KO 판정은 시뮬 안에서 바로 하되, 아나운서 · 라운드 종료 · 결과 기록은 confirmedTick ≥ koTick일 때만 시작하게 해 줘(최대 롤백 8f, KO 정지 40f). 강P(발생 10)로 0틱 KO가 나는 장면을 ① 예측이 맞은 경우 ② 실제 입력이 −3틱 백대시(무적 1–7)라 5틱에 되감기 되는 경우로 이어 재생하고, A 화면(즉시 KO 표시 → 취소)과 B 화면(확정 뒤 표시)을 작은 창 두 개와 로컬 · 확정 · 정지 구간 타임라인으로 보여 줘.

라이브 데모 열기 — KO 연출은 확정 틱 뒤에 (시뮬은 바로 KO · 아나운서 · 라운드 끝은 확정 ≥ KO 틱 · KO 정지 40f > 최대 롤백 8f)

오프라인은 vblank마다 1틱 (60 Hz 누적기를 59.94 Hz 화면에 쓰면 999프레임마다 2틱 · 60.05 Hz면 1,201프레임마다 0틱 · 잠그면 라운드가 99.10 s)

Offline tick pacing: run exactly one simulation tick per display vblank instead of a 60 Hz accumulator, which on a 59.94 Hz screen runs two ticks in one frame every 999 frames

  • C++
  • C#
  • Unity

보통의 고정 시간 누적기는 59.94 Hz 화면에서 프레임마다 0.1 %씩 시간이 남아 999프레임(16.7 s)마다 한 프레임에 두 틱을 돌리므로, 그 사이 한 틱은 화면에 나오지 않고 입력도 한 번만 읽힌 채 두 틱에 쓰여 1f 링크가 그 순간만 어긋납니다. 60.05 Hz 화면에서는 1,201프레임마다 틱이 없는 프레임이 생겨 같은 그림이 두 번 나오고 입력이 1f 늦습니다. 오프라인 대전은 vblank마다 정확히 1틱으로 잠그고 게임 속도가 0.1 % 바뀌는 것을 받아들여, 5,940틱 라운드가 59.94 Hz에서 99.10 s, 60.05 Hz에서 98.92 s가 됩니다.

프롬프트

오프라인 모드의 메인 루프를 vblank 콜백마다 입력 읽기 → 시뮬 1틱 → 그리기로 잠그고, 누적기(acc += dt; while acc ≥ 1/60 tick)는 온라인 시간 맞추기에만 쓰게 해 줘. 59.94 Hz 화면에서 누적기가 2틱을 도는 499번째 프레임 앞뒤 16프레임을 필름 칸으로 그려 A(누적기: 빨간 2틱 칸 · 안 보이는 틱)와 B(잠금: 매 칸 1틱)를 비교하고, 아래에 999프레임 · 1,201프레임 주기와 99.10 s · 98.92 s 라운드 길이를 띄워 줘.

라이브 데모 열기 — 오프라인은 vblank마다 1틱 (60 Hz 누적기를 59.94 Hz 화면에 쓰면 999프레임마다 2틱 · 60.05 Hz면 1,201프레임마다 0틱 · 잠그면 라운드가 99.10 s)

CPU도 가상 패드로 입력 (AI는 2 B 입력 단어만 쓴다 → SOCD · 버퍼 · 모션 판정을 사람과 똑같이 지남 · 리플레이에도 남는다)

The CPU drives a virtual pad: AI writes per-tick input words that go through the same SOCD, buffer and motion parser as a human, instead of writing character state directly

  • C#
  • Unity
  • C++

AI가 캐릭터 상태를 직접 "승룡"으로 바꾸면 커맨드 입력 시간도, 행동 가능 프레임도 건너뛰어 MP 가드 경직 중인 14틱에 승룡이 나가 −2인 기술을 반격합니다. 리플레이는 입력만 저장하므로 다시 재생하면 P2는 아무것도 하지 않고 서 있습니다. AI가 패드 단어(4 · 6 · 2 · 3+P)를 쓰게 하면 승룡은 버퍼를 거쳐 첫 행동 가능 20틱에 나가 24틱 지속이 되고, 22틱부터 행동 가능한 P1에게 막혀 프레임 표대로 반격이 안 됩니다.

프롬프트

CPU 컨트롤러가 매 틱 플레이어 2 패드 슬롯에 2바이트 입력 단어(방향 4비트 + 버튼 6비트)만 쓰고, 그 뒤는 사람 입력과 같은 SOCD → 숫자 표기 → 버튼 버퍼 → 모션 판정을 지나게 해 줘. P1 MP(발생 7 · 지속 3 · 후딜 12, 가드 −2)를 막은 CPU가 승룡(발생 5)으로 반격하려는 장면을 A(상태 직접 대입: 경직 중 14틱 발동 · 리플레이에 입력 0)와 B(패드: 17–19틱 6 · 2 · 3P → 20틱 발동 · 가드됨)로 나란히 보여 주고 파이프라인 상자와 P2 입력 테이프를 그려 줘.

라이브 데모 열기 — CPU도 가상 패드로 입력 (AI는 2 B 입력 단어만 쓴다 → SOCD · 버퍼 · 모션 판정을 사람과 똑같이 지남 · 리플레이에도 남는다)

판정 데이터는 구간 + 린트 (로드 때 프레임 배열로 컴파일 · 판정 = 발생 ~ 발생 + 지속 − 1 · 모든 프레임에 피격 상자 · 끝 = 전체 길이)

Hit/hurt box data authored as frame spans, compiled to a per-frame array at load and linted against the move's frame table on every build

  • C#
  • Unity
  • Python

상자를 프레임마다 그리는 대신 (종류 · 시작 · 끝 · 사각형) 구간 4줄로 저장하고, 로드할 때 frames[전체 길이] 배열로 한 번 펼쳐 틱마다 바로 꺼내 씁니다. 빌드마다 린트가 판정 구간 = 발생 ~ 발생 + 지속 − 1, 모든 프레임에 피격 상자 1개 이상, 판정은 늘어난 팔 구간 안, 구간 끝 = 전체 길이를 검사합니다. 강P 발생만 10에서 11로 고치고 상자를 그대로 두면 10–13 ≠ 11–14와 32f 빈 피격 상자 두 오류로 빌드가 멈춥니다.

프롬프트

기술 데이터를 상자 구간 목록(밀림 1–31 · 피격 몸 1–31 · 피격 팔 9–20 · 판정 10–13)과 프레임 표(발생 10 · 지속 4 · 후딜 18)로 저장하고, 로드 때 frames[31]로 컴파일한 뒤 4가지 린트 규칙을 돌리는 도구를 만들어 줘. 왼쪽에 현재 프레임의 상자를 그린 캐릭터, 오른쪽에 구간 타임라인과 표 막대, 아래에 규칙별 OK / ERR를 보여 주고, 두 번째 반복에서 발생만 11로 바꿔 빌드가 막히는 것을 보여 줘.

라이브 데모 열기 — 판정 데이터는 구간 + 린트 (로드 때 프레임 배열로 컴파일 · 판정 = 발생 ~ 발생 + 지속 − 1 · 모든 프레임에 피격 상자 · 끝 = 전체 길이)

키 설정은 SOCD 앞 한 층 (기기 버튼 → 논리 LP…HK · 단축 버튼 = 같은 틱 엣지 2개 · 리플레이 · 넷코드는 논리 단어만)

Input remap layer ahead of SOCD: device buttons map to logical LP–HK (a shortcut emits two edges on one tick), and replays and netplay carry only the 2-byte logical word

  • C#
  • Unity
  • Godot

패드든 키보드든 먼저 기기 버튼을 논리 버튼 LP MP HP LK MK HK로 바꾸고, 그다음 SOCD 정리와 숫자 표기, 버퍼가 논리 입력만 읽게 합니다. 잡기 단축 버튼은 LP와 LK를 같은 틱에 둘 다 누른 엣지로 만들어 동시 누름 판정을 그대로 통과합니다. 리플레이와 넷코드가 기기 코드가 아니라 2바이트 논리 단어만 저장하므로 배치가 다른 두 사람의 경기가 어느 기기에서나 같은 경기로 재생됩니다.

프롬프트

입력 계층을 기기 버튼 → 사용자 배치표 → 논리 단어(방향 4비트 + LP MP HP LK MK HK 6비트, 2바이트) → SOCD → 숫자 표기 → 버퍼 순서로 만들고, 단축 버튼(L1 = LP+LK)은 같은 틱 엣지 2개를 내게 해 줘. P1 패드(A · B · C · D · R1 · R2 · L1)와 P2 키보드(J K L M , . H) 배치가 연결선으로 같은 논리 버튼에 닿고 비트 칸과 16진 값이 켜지는 것, 10틱 단축 잡기가 나가는 작은 장면, 논리 단어 테이프를 22틱 동안 보여 줘.

라이브 데모 열기 — 키 설정은 SOCD 앞 한 층 (기기 버튼 → 논리 LP…HK · 단축 버튼 = 같은 틱 엣지 2개 · 리플레이 · 넷코드는 논리 단어만)

판정은 상태 프레임 스크립트로 (f10 hit on · f14 hit off · 애니 이벤트 0.150 s에 묶으면 50 fps에서 11틱 · 재시뮬에선 안 생김)

Spawn hitboxes from a per-move script keyed by simulation frame, not from animation events, which drift with render rate and never fire during rollback re-simulation

  • Unity
  • Unreal
  • C#

판정을 애니메이션 이벤트(0.150 s)에 걸어 두면 60 fps 렌더에서는 10틱에 생기지만 50 fps에서는 0.16 s 프레임에 처리되어 11틱에 생기고, 롤백 재시뮬은 애니메이션을 돌리지 않으므로 아예 생기지 않아 상대 화면과 갈라집니다. 기술마다 f1 vel 0 · f10 hit on · f14 hit off · f20 cancel · f31 end 같은 상태 프레임 스크립트를 두고 시뮬이 그 프레임에 실행하면 세 경우 모두 10틱입니다. 그림도 표[상태 · 프레임]에서 고르면 되감기 뒤에도 그대로 맞습니다.

프롬프트

기술 데이터에 상태 프레임 스크립트(f1 vel 0, f10 hit on, f14 hit off, f20 cancel open, f31 end)를 넣고 시뮬 틱이 그 프레임에 도달할 때 실행하게 해 줘. 강P(발생 10 · 지속 4 · 후딜 18)를 60 fps · 50 fps · 롤백 재시뮬 세 번 돌려 A(애니 이벤트 0.150 s: 10 · 11 · 없음)와 B(스크립트: 10 · 10 · 10)를 두 줄로 비교하고, 각 줄에 31칸 프레임 막대와 판정이 생긴 틱을 표시해 줘.

라이브 데모 열기 — 판정은 상태 프레임 스크립트로 (f10 hit on · f14 hit off · 애니 이벤트 0.150 s에 묶으면 50 fps에서 11틱 · 재시뮬에선 안 생김)

더미 녹화는 앞 · 뒤 기준 (숫자 표기 6 = 앞으로 저장 · 재생 때 지금 방향을 곱함 · 절대 ←로 저장하면 사이드 바꾼 뒤 대시가 백대시)

Training dummy recording slots store numpad directions relative to facing and apply the current facing on playback, so a recorded dash still dashes after a side swap

  • C#
  • Unity
  • Godot

오른쪽에서 왼쪽을 보며 녹화한 대시 + 앉아 MK를 절대 좌우(←)로 저장하면 연습 모드에서 사이드를 바꾼 뒤 ←가 뒤가 되어 60 px 백대시가 나가고, 백대시 24f 동안 2MK 버퍼(4f)가 만료되어 앉기만 합니다. 녹화를 숫자 표기(6 · 5 · 6 · 5 · 2MK)로 저장하고 재생할 때 더미의 지금 방향을 곱하면 어느 쪽에서든 72 px 대시 뒤 2MK가 들어갑니다. 슬롯은 (값 2 B, 길이 1 B) 줄 5개와 머리 4 B로 19바이트입니다.

프롬프트

트레이닝 더미 녹화 슬롯을 머리 4 B(길이 · 녹화 방향 · 반복) + 입력 줄 {숫자 표기 값, 길이}로 저장하고 재생 때 현재 바라보는 방향을 곱해 줘. 녹화 6 × 3f · 5 × 2f · 6 × 3f · 5 × 12f · 2MK × 14f(대시 72 px / 18f, 백대시 60 px / 24f)를 오른쪽에서 한 번, 사이드를 바꿔 왼쪽에서 한 번 재생하며 A(절대 ←: 백대시 · 2MK 만료)와 B(숫자: 대시 · 2MK 적중)를 나란히 보여 주고, 오른쪽에 슬롯 줄 목록과 재생 중인 줄을 강조해 줘.

라이브 데모 열기 — 더미 녹화는 앞 · 뒤 기준 (숫자 표기 6 = 앞으로 저장 · 재생 때 지금 방향을 곱함 · 절대 ←로 저장하면 사이드 바꾼 뒤 대시가 백대시)

잡기 착지점은 시작 틱에 계산 (뒤 던지기 = 공격자 − 60 px · 벽 밖으로 넘친 55 px는 30f 동안 공격자를 민다 · 끝에 놓고 맞추면 25 px 튕김)

Throw relocation near a wall: compute and clamp the defender's landing spot when the throw connects and shift the attacker by the overflow during the animation, instead of snapping at the end

  • C#
  • Unity
  • C++

벽을 등진 P1(x 20)이 뒤 던지기를 하면 착지점이 20 − 60 = −40으로 벽(15) 밖입니다. 애니메이션이 끝나는 37틱에 상대를 −40에 놓고 벽에 맞추면 P1과 25 px 겹쳐 밀림 상자가 P1을 한 틱에 25 px 튕겨 냅니다. 잡기가 성립한 틱에 착지점을 먼저 계산해 벽 안으로 맞추고, 넘친 55 px를 던지기 30f 동안 공격자에게 부드럽게 옮기면 끝났을 때 간격 60이 그대로이고 상대는 구석에 갑니다.

프롬프트

잡기(발생 7 · 범위 40 px)가 성립한 틱에 상대 착지점 = 공격자 x + 방향 × 오프셋(뒤 던지기 −60)을 계산해 벽(밀림 중심 최소 15) 안으로 자르고, 잘린 양만큼 공격자 위치를 30f 던지기 동안 easeInOut으로 옮기게 해 줘. 벽 앞 x 20에서 54에 있는 상대를 뒤로 던지는 장면을 A(끝에 놓고 맞춤 → 37틱 25 px 튕김)와 B(먼저 계산 → P1 75 · P2 15)로 나란히 재생하고 오른쪽 패널에 계산 단계를 줄마다 켜 줘.

라이브 데모 열기 — 잡기 착지점은 시작 틱에 계산 (뒤 던지기 = 공격자 − 60 px · 벽 밖으로 넘친 55 px는 30f 동안 공격자를 민다 · 끝에 놓고 맞추면 25 px 튕김)

라운드 사이 초기화 목록 (FIGHT 틱에 버퍼 · 입력 이력 · 경직 · 장풍 비움 · 게이지 · 승수 · 난수는 유지 · 버퍼를 남기면 FIGHT +1틱 장풍)

Round transition reset list: what returns to defaults on the FIGHT tick and what carries over; a surviving input buffer fires a special on the first frame

  • C#
  • Unity
  • C++

KO 슬로 동안 236 HP를 연타한 입력이 버튼 버퍼와 32f 입력 이력에 남은 채 라운드 연출 동안 시뮬이 멈춰 있으면, ROUND 2 → FIGHT 첫 틱에 지난 라운드 입력으로 장풍이 나갑니다. FIGHT 틱에 위치 ±70 · 체력 10,000 · 타이머 5,940 · 경직 · 장풍 슬롯 · 버퍼 · 입력 이력 · 콤보 보정을 초기화하고, 게이지 · 라운드 승수 · 난수 상태는 이어 갑니다. 이미 눌려 있는 버튼은 레벨로만 남겨 엣지가 생기지 않게 합니다.

프롬프트

라운드 전환 함수를 초기화 목록(위치 ±70 · 속도 · 체력 10,000 · 타이머 5,940 · 경직 · 정지 · 무적 · 장풍 슬롯 · 버튼 버퍼 · 입력 이력 32f · 콤보 · 보정 · 저글)과 유지 목록(게이지 · 라운드 승수 · 난수 상태 · 눌린 버튼 레벨)으로 나눠 FIGHT 틱에 한 번에 적용해 줘. KO 슬로 중 236 HP 연타 → ROUND 2 → FIGHT를 A(버퍼 · 이력 남김: FIGHT +1틱 장풍)와 B(목록대로: 아무것도 안 나감)로 나란히 보여 주고 아래에 12칸 점검표를 그려 줘.

라이브 데모 열기 — 라운드 사이 초기화 목록 (FIGHT 틱에 버퍼 · 입력 이력 · 경직 · 장풍 비움 · 게이지 · 승수 · 난수는 유지 · 버퍼를 남기면 FIGHT +1틱 장풍)

KO 슬로는 틱을 건너뛴다 (×0.25 = 화면 4프레임에 시뮬 1틱 · 화면만 보간 · dt × 0.25로 돌리면 같은 띄우기가 2.4 px 더 높다)

KO slow motion by tick scheduling: run one simulation tick every fourth display frame and interpolate only the render, instead of scaling dt, which changes Euler results

  • C++
  • C#
  • Unity

KO 슬로(×0.25, 48 프레임)를 dt × 0.25로 만들면 반-암시 오일러 적분의 결과가 dt에 따라 달라져 같은 띄우기(vx 4 · vz 8.4 · 점프와 같은 공용 중력 0.53 = 192/361)가 12틱 뒤 59.32가 아니라 61.71 높이에 있고 최고점도 62.18 → 64.57이 됩니다. 그 차이는 리플레이와 롤백 해시를 어긋나게 하고 프레임 카운터도 소수가 됩니다. 시뮬은 화면 4프레임에 1틱만 돌리고 화면은 두 틱 사이를 보간만 하면 궤적이 보통 속도와 비트 단위로 같습니다.

프롬프트

슬로 모션을 시뮬 스케줄러에서 처리해 ×0.25 동안 화면 4프레임마다 1틱만 진행하고, 렌더는 이전 · 현재 틱 상태를 보간해서 그려 줘. KO로 띄워진 상대(vx 4, vz 8.4, 공용 중력 192/361 ≈ 0.53 px/f²)를 48프레임 슬로 뒤 보통 속도로 이어 그리며 B(틱 건너뛰기: 초록 점)와 A(dt × 0.25: 주황 점선 · 반투명 고스트)를 겹쳐 보여 주고, 아래에 화면 프레임 / 틱 눈금과 12틱 높이 · 최고점 비교표를 띄워 줘.

라이브 데모 열기 — KO 슬로는 틱을 건너뛴다 (×0.25 = 화면 4프레임에 시뮬 1틱 · 화면만 보간 · dt × 0.25로 돌리면 같은 띄우기가 2.4 px 더 높다)

가드 경직 중엔 가드 유지 (←는 행동 가능할 때만 읽음 · 경직 중 ↓만 높이를 바꿈 · 맞을 때마다 ← 확인하면 갭 0 연타가 맞는다)

Blocking rule: while in blockstun the defender keeps guarding automatically (only crouch changes height); back is read only when actionable, so a gap-0 string can never hit a mashing defender

  • C#
  • Unity
  • C++

가드할 때마다 그 틱에 ←가 눌려 있는지 검사하면, 약P 가드 경직(8f, 5–12틱) 중 반격하려고 9틱에 ←를 떼고 약P를 연타한 수비자가 갭 0으로 12틱에 닿는 2타에 맞아 진짜 콤보가 아닌데도 콤보가 됩니다. 가드 경직 안에서는 입력과 상관없이 가드를 유지하고 ↓로 높이만 바꾸게 하면 같은 장면이 가드로 끝나고, 경직이 끝난 13틱부터 다시 ←를 읽습니다. 그래서 가드 연속기의 빈틈 판정이 입력 습관이 아니라 프레임 데이터로만 정해집니다.

프롬프트

가드 판정을 "행동 가능 상태에서 ← 입력 또는 가드 경직 중"으로 만들고, 가드 경직 중에는 ↓ 입력으로 서서 · 앉아 가드 높이만 바꾸게 해 줘. 약P(발생 4 · 지속 2)를 막은 뒤 6틱 캔슬 2타가 12틱에 닿고 수비자가 9–13틱 ←를 떼는 장면을 A(매번 ← 확인: 12틱 피격)와 B(경직 중 자동 가드: 가드)로 나란히 보여 주고, 오른쪽에 P1 · P2 ← · P2 상태 세 줄 프레임 막대를 그려 줘.

라이브 데모 열기 — 가드 경직 중엔 가드 유지 (←는 행동 가능할 때만 읽음 · 경직 중 ↓만 높이를 바꿈 · 맞을 때마다 ← 확인하면 갭 0 연타가 맞는다)

점프 궤도는 프레임 표 (y[f] 정수 39칸 · 정점 96 @ f19 · 착지 f38 정확 · 반올림한 v0 10.1 · g 0.53 오일러는 101.3 · f40)

Jump arcs as per-frame integer height tables: apex 96 at frame 19 and landing exactly on frame 38, versus float Euler integration with rounded v0 and gravity

  • C#
  • Unity
  • C++

점프를 초속 10.1과 중력 0.53 같은 반올림한 실수로 적분하면 정점이 101.3(f20)으로 오르고 f40에 −9.4까지 내려가 바닥에 붙이므로 공중 38f라는 프레임 데이터가 40f가 됩니다. 캐릭터마다 y[f] 정수 표 39칸(78 B)을 두면 정점 96(f19)과 착지 f38이 정확하고, 점프 공격 판정 높이 같은 공중 프레임 데이터도 같은 표에서 읽습니다. 고정소수 좌표라 롤백 · 리플레이에서도 비트 단위로 같습니다.

프롬프트

점프를 물리 적분 대신 캐릭터별 정수 높이 표 y[0..38] = round(96·4f(38−f)/38²)로 만들고, 수평 이동만 속도로 더하게 해 줘. 그래프에 표(금색 점)와 v0 10.1 · g 0.53 오일러(주황 선)를 프레임마다 그려 가며 캐릭터를 표 위로 뛰게 하고, 오른쪽 패널에 정점 96 @ f19 · 착지 f38과 101.3 @ f20 · 착지 f40을 비교해 줘.

라이브 데모 열기 — 점프 궤도는 프레임 표 (y[f] 정수 39칸 · 정점 96 @ f19 · 착지 f38 정확 · 반올림한 v0 10.1 · g 0.53 오일러는 101.3 · f40)

슬롯 바꿔 돌리기 테스트 (녹화 대전을 P1 · P2 슬롯 번호만 바꿔 다시 실행 · 틱마다 상태가 같아야 함 · 다르면 그 틱이 1P 편향)

Slot-swap symmetry test: rerun recorded matches with the P1 and P2 slot indices exchanged (same characters, sides and inputs) and compare every tick, so any divergence exposes slot-order bias

  • C++
  • C#
  • Python

두 캐릭터를 배열 순서대로 처리하는 코드는 겉보기엔 멀쩡해도 같은 틱에 일이 겹치면 0번 슬롯이 이기는 편향이 숨어 있습니다. 녹화한 대전을 캐릭터 · 위치 · 입력은 그대로 두고 슬롯 번호만 바꿔 다시 돌리면 결과가 완전히 같아야 하므로, 장풍 판정을 슬롯 순서로 한 번에 돌리는 코드는 29틱에 원본은 오른쪽 피격, 바꾼 쪽은 상쇄로 갈라져 그 틱이 바로 보고됩니다. 장풍 판정을 두 단계로 고친 뒤에는 1,000판 모두 같아 CI를 통과합니다.

프롬프트

CI에 슬롯 교환 테스트를 넣어 녹화 대전 1,000판을 원본과 P1 · P2 슬롯 번호만 바꾼 버전(캐릭터 · 위치 · 입력 동일)으로 헤드리스 재생하고, 틱마다 두 캐릭터 상태를 비교해 처음 다른 틱과 그 틱에 돈 시스템 이름을 보고하게 해 줘. 4 px/f 장풍 둘이 29틱에 몸과 장풍에 함께 겹치는 장면을 두 줄로 돌려 슬롯 순서 코드(29틱 불일치)와 2단계 코드(0 / 1,000 불일치)를 이어 보여 주고, 오른쪽에 최근 10틱 같음 / 다름 목록을 그려 줘.

라이브 데모 열기 — 슬롯 바꿔 돌리기 테스트 (녹화 대전을 P1 · P2 슬롯 번호만 바꿔 다시 실행 · 틱마다 상태가 같아야 함 · 다르면 그 틱이 1P 편향)

프레임 표는 측정해서 만든다 (헤드리스 테스트가 첫 적중 · 양쪽 행동 가능 틱을 재서 표 생성 · 위키 표와 다르면 CI 실패)

Frame data generated by measurement: a headless test plays each move against a dummy, records first hit and both actionable ticks, writes the published table, and fails CI when hand-written numbers drift

  • C#
  • Python
  • Unity

프레임 표를 손으로 쓰면 후딜 하나를 고쳐도 숫자가 그대로 남습니다. 테스트가 공격자와 더미를 붙여 놓고 기술마다 첫 적중 틱, 공격자 행동 가능 틱, 더미 행동 가능 틱을 재서 유불리 = 더미 − 공격자를 계산하면 LP +1 · MP −2 · HP −5 · 2LK −1이 표와 같고, v13에서 강P 후딜을 18 → 19로 바꾸면 −6이 측정되어 위키의 −5와 달라져 CI가 멈춥니다. 훈련 모드 표시, 위키, AI 반격표가 모두 이 생성 파일을 읽습니다.

프롬프트

헤드리스 시뮬로 기술마다 공격자와 가드하는 더미를 사거리에 두고 1틱에 기술을 눌러 첫 적중 · 공격자 행동 가능 · 더미 행동 가능 틱을 기록하고, 유불리 = 더미 − 공격자로 frame_data.json을 생성해 손으로 쓴 표와 다르면 CI를 실패시키게 해 줘. LP(4 · 2 · 6, 가드 경직 8) · MP(7 · 3 · 12, 12) · HP(10 · 4 · 18, 16) · 2LK(5 · 2 · 8, 8)를 차례로 돌리는 작은 장면, 측정 표, 로그를 보여 주고 두 번째 반복에서 강P 후딜 19로 −6 · CI 실패를 띄워 줘.

라이브 데모 열기 — 프레임 표는 측정해서 만든다 (헤드리스 테스트가 첫 적중 · 양쪽 행동 가능 틱을 재서 표 생성 · 위키 표와 다르면 CI 실패)

타격 등급 표 하나로 (기술은 L · M · H만 고르고 정지 8 · 11 · 13 · 경직 12 · 15 · 18 · 밀림 · 스파크는 등급 행에서 · 예외는 덮어쓰기 목록)

Hit levels as a single data table: each move references L, M or H and the level row supplies hitstop, hitstun, blockstun, pushback and spark; exceptions live in an override list

  • C#
  • Unity
  • Python

기술마다 정지 · 경직 · 밀림 숫자를 따로 적으면 같은 강공격끼리 숫자가 어긋나고 패치 때 수십 칸을 고쳐야 합니다. 기술 데이터에는 등급(L · M · H)만 적고 등급 표가 정지 8 · 11 · 13, 피격 경직 12 · 15 · 18, 가드 경직 8 · 12 · 16, 밀림과 스파크 크기를 주게 하면, H 경직을 18 → 17로 바꾸는 칸 하나로 강 노멀 7개와 강 필살 3개가 함께 바뀝니다. 2HK 하드 다운처럼 예외는 덮어쓰기 목록에만 두고 10 %를 넘으면 등급을 하나 더 만듭니다.

프롬프트

타격 등급 표(L: 정지 8 · 경직 12 · 가드 8 · 밀림 10 / 8 px, M: 11 · 15 · 12 · 14 / 12, H: 13 · 18 · 16 · 20 / 16, 가드 쪽 정지 −1)를 만들고 기술은 { move, level } 과 덮어쓰기만 갖게 해 줘. 약 · 중 · 강 세 장면이 표 숫자대로 정지하고 밀리는 것을 나란히 반복하고, 아래 표와 함께 후반에 H 경직 18 → 17 패치가 칸 하나로 10개 기술에 퍼지는 것을 보여 줘.

라이브 데모 열기 — 타격 등급 표 하나로 (기술은 L · M · H만 고르고 정지 8 · 11 · 13 · 경직 12 · 15 · 18 · 밀림 · 스파크는 등급 행에서 · 예외는 덮어쓰기 목록)

싱크 테스트 (매 틱 저장 → 진행 → 해시 A · 불러오기 → 진행 → 해시 B · 다르면 멈추고 필드 비교 · 스냅숏 밖 전역 변수를 찾는다)

Rollback sync test: every tick save, step and hash, then load, step and hash again; a mismatch stops the game and diffs fields to find state living outside the snapshot

  • C++
  • C#
  • Unity

롤백 넷코드는 불러온 스냅숏에서 다시 진행해도 같은 결과가 나와야 하는데, 콤보 타이머 같은 값이 전역 static에 있으면 불러오기로 돌아가지 않아 두 번째 진행이 다른 값을 봅니다. 개발 빌드에서 매 틱 저장 → 진행 → 해시 A, 불러오기 → 진행 → 해시 B를 비교하면 콤보 2타가 들어가는 1024틱에 해시가 갈라지고, 필드 비교가 comboTimer A 6 · B 12를 짚어 줍니다. 그 값을 캐릭터 상태 구조체로 옮기면 312바이트 스냅숏에 포함되어 온라인 디싱크를 대전 전에 막습니다.

프롬프트

개발 빌드에 싱크 테스트 모드를 넣어 매 틱 save() → step() → hashA, load() → step() → hashB를 계산하고, 다르면 게임을 멈추고 스냅숏 필드를 하나씩 비교해 다른 이름과 값을 띄워 줘. 1012틱부터 약P 콤보를 넣는 트레이닝 장면 옆에 7단계 파이프라인 상자를 돌리고, 아래에 최근 9틱 해시 A · B 칸을 그려 1024틱에서 빨갛게 갈라진 뒤 "comboTimer A 6 · B 12 — 전역 static" 보고를 보여 줘.

라이브 데모 열기 — 싱크 테스트 (매 틱 저장 → 진행 → 해시 A · 불러오기 → 진행 → 해시 B · 다르면 멈추고 필드 비교 · 스냅숏 밖 전역 변수를 찾는다)