25강결정론적 시뮬레이션

var a := 0.1 + 0.2
print(a == 0.3)   # false!

randf()          # 매번 다름 → 비결정적

for id in enemies:          # 순서가 보장되나?
	enemies[id].update()

var ids := enemies.keys()
ids.sort()
for id in ids:
	enemies[id].update()

position += velocity * delta  # delta가 매번 다르면 결과도 다름

# res://autoload/replay.gd
extends Node

enum Mode { OFF, RECORD, PLAYBACK }

var mode: Mode = Mode.OFF
var frame := 0
var seed_value := 0

var _frames: Array = []  # [{f: 프레임, dir: Vector2, act: 비트}]
var _play_index := 0

# ── 기록 시작 ─────────────────
func start_record() -> void:
	mode = Mode.RECORD
	frame = 0
	_frames.clear()
	seed_value = randi()
	_apply_seed()

# ── 매 물리 프레임 호출 ────────────
func capture(dir: Vector2, actions: int) -> void:
	if mode != Mode.RECORD:
		return
	# 값이 바뀔 때만 기록한다 (용량 절약)
	if _frames.is_empty() \
			or _frames[-1].dir != dir \
			or _frames[-1].act != actions:
		_frames.append({
			"f": frame, "dir": dir, "act": actions,
		})

# ── 재생 시 이번 프레임의 입력 ─────────
func get_input() -> Dictionary:
	if mode != Mode.PLAYBACK:
		return {}
	while _play_index + 1 < _frames.size() \
			and _frames[_play_index + 1].f <= frame:
		_play_index += 1
	if _frames.is_empty():
		return {"dir": Vector2.ZERO, "act": 0}
	return _frames[_play_index]

func tick() -> void:
	frame += 1

# ── 저장 / 불러오기 ──────────────
func save(path := "user://replay.json") -> void:
	var f := FileAccess.open(path, FileAccess.WRITE)
	f.store_string(JSON.stringify({
		"version": 1,
		"seed": seed_value,
		"length": frame,
		"frames": _frames.map(func(x): return {
			"f": x.f,
			"dx": x.dir.x, "dy": x.dir.y,
			"a": x.act,
		}),
	}))

func load_replay(path := "user://replay.json") -> bool:
	if not FileAccess.file_exists(path):
		return false
	var f := FileAccess.open(path, FileAccess.READ)
	var d = JSON.parse_string(f.get_as_text())
	if typeof(d) != TYPE_DICTIONARY:
		return false
	seed_value = int(d.seed)
	_frames = (d.frames as Array).map(func(x): return {
		"f": int(x.f),
		"dir": Vector2(x.dx, x.dy),
		"act": int(x.a),
	})
	_play_index = 0
	frame = 0
	mode = Mode.PLAYBACK
	_apply_seed()
	return true

func _apply_seed() -> void:
	Game.rng.seed = seed_value
	Game.rng.state = 0

extends CharacterBody2D

const ACT_ATTACK := 1
const ACT_JUMP := 2

func _physics_process(_delta: float) -> void:
	var dir: Vector2
	var act: int

	if Replay.mode == Replay.Mode.PLAYBACK:
		var r := Replay.get_input()
		dir = r.get("dir", Vector2.ZERO)
		act = r.get("act", 0)
	else:
		dir = Input.get_vector("move_left", "move_right",
			"move_up", "move_down")
		act = 0
		if Input.is_action_pressed("attack"):
			act |= ACT_ATTACK
		if Input.is_action_pressed("jump"):
			act |= ACT_JUMP
		Replay.capture(dir, act)

	_simulate(dir, act)
	Replay.tick()

# 입력만 받아서 상태를 바꾸는 순수한 함수
func _simulate(dir: Vector2, act: int) -> void:
	velocity = dir * 300.0
	move_and_slide()
	if act & ACT_ATTACK:
		_attack()

func snapshot() -> Dictionary:
	return {
		"pos": global_position,
		"vel": velocity,
		"hp": hp,
		"state": state,          # 16강의 상태 머신
		"state_time": _state_time,
		"cooldown": _cooldown,
	}

func restore(s: Dictionary) -> void:
	global_position = s.pos
	velocity = s.vel
	hp = s.hp
	state = s.state
	_state_time = s.state_time
	_cooldown = s.cooldown