24강지연과 예측

0ms    [클라] 오른쪽 키를 누름 → 서버에 전송
75ms   [서버] 받음. 이동 계산. 결과 전송
150ms  [클라] 결과 도착. 이제서야 캐릭터가 움직임

extends CharacterBody2D

const SPEED := 300.0

var _seq := 0
var _pending: Array = []  # 서버 확인을 기다리는 입력들

func _physics_process(delta: float) -> void:
	if not is_multiplayer_authority():
		return

	_seq += 1
	var input := {
		"seq": _seq,
		"dir": Input.get_vector("move_left", "move_right",
			"move_up", "move_down"),
		"dt": delta,
	}

	# 1) 즉시 내 화면에서 적용 (예측)
	_apply(input)
	_pending.append(input)

	# 2) 서버에 전송
	send_input.rpc_id(1, input)

func _apply(input: Dictionary) -> void:
	velocity = input.dir * SPEED
	move_and_slide()

# ── 서버 쪽 ──────────────────
@rpc("any_peer", "unreliable_ordered")
func send_input(input: Dictionary) -> void:
	if not multiplayer.is_server():
		return
	var sender := multiplayer.get_remote_sender_id()
	if sender != get_multiplayer_authority():
		return
	# 서버도 같은 계산을 한다
	_apply(input)
	# 결과를 원래 주인에게 돌려준다
	confirm.rpc_id(sender, input.seq, global_position)

# ── 클라이언트가 서버 답을 받음 ────────
@rpc("authority", "unreliable_ordered")
func confirm(seq: int, server_pos: Vector2) -> void:
	# 확인된 것보다 오래된 입력은 버린다
	while not _pending.is_empty() and _pending[0].seq <= seq:
		_pending.pop_front()

	# 예측과 서버가 크게 다르면 고친다
	if global_position.distance_to(server_pos) < 2.0:
		return  # 오차 무시 (작으면 그냥 둔다)

	global_position = server_pos
	# 아직 확인 안 된 입력들을 다시 적용 (재시뮬레이션)
	for input in _pending:
		_apply(input)

extends CharacterBody2D

const BUFFER_MS := 100.0   # 얼마나 과거를 보여줄까

var _history: Array = []  # [{t: 시각, pos: 위치}, ...]

@rpc("authority", "unreliable_ordered")
func update_state(pos: Vector2, t: float) -> void:
	_history.append({"t": t, "pos": pos})
	# 너무 오래된 건 버린다
	while _history.size() > 30:
		_history.pop_front()

func _process(_delta: float) -> void:
	if is_multiplayer_authority():
		return  # 내 캐릭터는 예측을 쓴다
	if _history.size() < 2:
		return

	var render_time := _now() - BUFFER_MS / 1000.0

	# render_time을 감싸는 두 지점을 찾는다
	for i in range(_history.size() - 1):
		var a: Dictionary = _history[i]
		var b: Dictionary = _history[i + 1]
		if a.t <= render_time and render_time <= b.t:
			var span: float = b.t - a.t
			var f: float = 0.0 if span <= 0.0 \
				else (render_time - a.t) / span
			global_position = (a.pos as Vector2).lerp(b.pos, f)
			return

	# 데이터가 안 왔으면 마지막 위치 유지(또는 외삽)
	global_position = _history[-1].pos

func _now() -> float:
	return Time.get_ticks_msec() / 1000.0

Network → Debug
  Simulate Packet Loss  = 0.05    (5% 손실)
  Simulate Packet Delay = 0.15    (150ms 지연)

# 개발 빌드에서만
if OS.is_debug_build():
	var peer := multiplayer.multiplayer_peer
	# ENet은 상황에 따라 API가 다르므로
	# 프로젝트 설정 쪽을 쓰는 게 확실하다
	pass

@export var fake_delay_ms := 150.0

func send_with_delay(callable: Callable, args: Array) -> void:
	if fake_delay_ms > 0.0:
		await get_tree().create_timer(
			fake_delay_ms / 1000.0).timeout
	callable.callv(args)