RPG（下）：战斗、状态机与存档

enum State { IDLE, CHASE, HURT }

var state := State.IDLE
var target: Node2D


func _physics_process(_delta: float) -> void:
	match state:
		State.IDLE:
			velocity = Vector2.ZERO
			if target and position.distance_to(target.position) < 64.0:
				state = State.CHASE
		State.CHASE:
			velocity = position.direction_to(target.position) * 50.0
		State.HURT:
			velocity *= 0.9
	move_and_slide()

enum State { IDLE, WANDER, CHASE, ATTACK, HURT, DEAD }

var state := State.IDLE
var state_time := 0.0        # 进入当前状态多久了

func _physics_process(delta: float) -> void:
	state_time += delta
	match state:
		State.IDLE:
			velocity = velocity.move_toward(Vector2.ZERO, 300.0 * delta)
			if _sees_player():
				change_state(State.CHASE)
			elif state_time > wander_interval:
				change_state(State.WANDER)
		State.WANDER:
			velocity = velocity.move_toward(_wander_dir * chase_speed * 0.45 * speed_scale, 300.0 * delta)
			if _sees_player():
				change_state(State.CHASE)
			elif state_time > wander_interval * 0.6 or get_slide_collision_count() > 0:
				change_state(State.IDLE)
		State.CHASE:
			var to_player := _player.global_position - global_position
			velocity = velocity.move_toward(to_player.normalized() * chase_speed * speed_scale, 400.0 * delta)
			if _lost_player():
				change_state(State.IDLE)
				_show_emote("?")
			elif to_player.length() < ATTACK_RANGE and state_time > 0.3:
				change_state(State.ATTACK)
		State.ATTACK:
			if state_time < WINDUP:                       # 蓄力：停下、抖动
				velocity = velocity.move_toward(Vector2.ZERO, 800.0 * delta)
				sprite.position.x = sin(state_time * 60.0) * 1.0
			elif not _lunged:                             # 扑出去
				_lunged = true
				sprite.position.x = 0.0
				velocity = _attack_dir * LUNGE_SPEED * speed_scale
			else:
				velocity = velocity.move_toward(Vector2.ZERO, 300.0 * delta)
				if state_time > WINDUP + 0.45:
					change_state(State.CHASE)
		State.HURT:
			velocity = velocity.move_toward(Vector2.ZERO, 500.0 * delta)   # 击退速度慢慢衰减
			if state_time > 0.3:
				change_state(State.CHASE)
		State.DEAD:
			return
	move_and_slide()
	_update_visual(delta)

func change_state(next: State) -> void:
	if state == State.DEAD:
		return                                   # 死了就不再切换
	var prev := state
	state = next
	state_time = 0.0
	match next:
		State.WANDER:
			_wander_dir = Vector2.from_angle(randf() * TAU)
		State.CHASE:
			if prev == State.IDLE or prev == State.WANDER:
				_show_emote("!")
		State.ATTACK:
			_attack_dir = global_position.direction_to(_player.global_position)
			_lunged = false
		State.HURT:
			sprite.position.x = 0.0
	hitbox.active = next != State.HURT and next != State.DEAD

class_name BaseState
extends Node

var machine: StateMachine


func enter(_msg := {}) -> void:
	pass


func exit() -> void:
	pass


func handle_input(_event: InputEvent) -> void:
	pass


func physics_update(_delta: float) -> void:
	pass

class_name StateMachine
extends Node

signal state_changed(from: StringName, to: StringName)

@export var initial_state: BaseState
var state: BaseState


func _ready() -> void:
	for child in get_children():
		if child is BaseState:
			child.machine = self
	await owner.ready          # 等角色本身准备好再进入第一个状态
	state = initial_state
	state.enter()


func _unhandled_input(event: InputEvent) -> void:
	if state:
		state.handle_input(event)


func _physics_process(delta: float) -> void:
	if state:
		state.physics_update(delta)


func transition_to(target: StringName, msg := {}) -> void:
	var next := get_node_or_null(NodePath(target)) as BaseState
	if next == null:
		push_error("没有这个状态：%s" % target)
		return
	var from := state.name
	state.exit()
	state = next
	state.enter(msg)
	state_changed.emit(from, target)

extends BaseState

const DURATION := 0.24
var _time := 0.0

@onready var player := owner as Player


func enter(_msg := {}) -> void:
	_time = 0.0
	player.start_swing()


func physics_update(delta: float) -> void:
	_time += delta
	player.move(delta, Vector2.ZERO)     # 挥剑时滑行减速
	if _time >= DURATION:
		machine.transition_to(&"Move")


func exit() -> void:
	player.end_swing()

extends BaseState

@onready var player := owner as Player


func physics_update(delta: float) -> void:
	player.move(delta, player.get_input_vector())
	player.play_walk_animation()


func handle_input(event: InputEvent) -> void:
	if event.is_action_pressed("attack") and player.can_attack():
		machine.transition_to(&"Attack")
	elif event.is_action_pressed("interact"):
		player.try_interact()

func _sees_player() -> bool:
	if _player == null or _player.is_dead():
		return false
	return global_position.distance_to(_player.global_position) <= sense_radius


func _lost_player() -> bool:
	return _player.is_dead() or global_position.distance_to(_player.global_position) > lose_radius

class_name Hitbox
extends Area2D

@export var damage := 1
@export var knockback := 120.0     ## 击退初速度（像素/秒）
@export var active := true:        ## 关掉时 Hurtbox 会忽略它（比如剑没挥出来、敌人正在受伤）
	set(v):
		active = v
		for c in get_children():
			if c is CollisionShape2D:
				c.set_deferred("disabled", not v)


func _ready() -> void:
	monitoring = false
	active = active

class_name Hurtbox
extends Area2D

signal hurt(hitbox: Hitbox)

var invincible := false


func _ready() -> void:
	monitorable = false
	area_entered.connect(_on_area_entered)


func _on_area_entered(area: Area2D) -> void:
	if area is Hitbox and area.active and not invincible:
		hurt.emit(area)


## 开启无敌 seconds 秒。期间别人打不到，结束后重新检查一次重叠。
func start_invincibility(seconds: float) -> void:
	invincible = true
	await get_tree().create_timer(seconds, false).timeout
	invincible = false
	for area in get_overlapping_areas():
		if area is Hitbox and area.active:
			hurt.emit(area)
			break

func can_attack() -> bool:
	return _cooldown <= 0.0


func start_swing() -> void:
	_cooldown = attack_cooldown
	sprite.flip_h = facing.x < 0
	sprite.play("attack_" + _dir_name())
	# 剑的枢轴朝向 facing：枢轴旋转 0 时剑尖朝上（-Y），所以要加 90°
	sword_pivot.rotation = facing.angle() + PI / 2.0
	move_child(sword_pivot, 0 if facing.y < 0 else -1)   # 朝上挥时剑画在身体后面
	sword.visible = true
	sword.rotation = -1.2
	create_tween().tween_property(sword, "rotation", 1.2, 0.14).set_ease(Tween.EASE_OUT).set_trans(Tween.TRANS_CUBIC)
	slash.play()
	sword_hitbox.active = true


func end_swing() -> void:
	sword_hitbox.active = false
	sword.visible = false

[layer_names]

2d_physics/layer_1="world"
2d_physics/layer_2="water"
2d_physics/layer_3="player"
2d_physics/layer_4="enemy"
2d_physics/layer_5="player_attack"
2d_physics/layer_6="enemy_attack"
2d_physics/layer_7="interact"
2d_physics/layer_8="pickup"

func _ready() -> void:
	collision_layer = 0
	set_collision_layer_value(3, true)    # 我在第 3 层 player
	collision_mask = 0b11                 # 我会撞到第 1 层 world 和第 2 层 water
	print(get_collision_mask_value(2))    # true


func become_ghost() -> void:
	set_collision_mask_value(2, false)    # 不再被水挡住（像蝙蝠一样）

func _on_hurt(attack: Hitbox) -> void:
	if state == State.DEAD:
		return
	hp -= attack.damage
	# 击退：沿"攻击者 → 自己"的方向给一个初速度，HURT 状态里再慢慢减到 0
	velocity = attack.global_position.direction_to(global_position) * attack.knockback
	_flash()
	if hp <= 0:
		_die()
	else:
		change_state(State.HURT)
		hurtbox.start_invincibility(0.25)     # 一次挥剑只算一下

[sub_resource type="ShaderMaterial" id="flash"]
resource_local_to_scene = true
shader = ExtResource("3")
shader_parameter/flash = 0.0
shader_parameter/flash_color = Color(1, 1, 1, 1)

func _on_hurt(hitbox: Hitbox) -> void:
	if is_dead():
		return
	Game.change_hp(-hitbox.damage)
	var dir := (global_position - hitbox.global_position).normalized()
	if Game.hp <= 0:
		machine.transition_to(&"Dead")
		return
	machine.transition_to(&"Hurt", {"knockback": dir * hitbox.knockback})
	hurtbox.start_invincibility(invincible_time)   # 无敌帧：这段时间里 Hurtbox 不再响应
	_blink = invincible_time

class_name ItemData
extends Resource

@export var id: StringName
@export var display_name := ""
@export_multiline var description := ""
@export var icon: Texture2D
@export_range(1, 99) var max_stack := 9
@export var heal := 0        ## 使用后回复多少血（半颗心 = 1）；0 表示不能直接使用

[gd_resource type="Resource" script_class="ItemData" load_steps=4 format=3]

[ext_resource type="Script" path="res://items/item_data.gd" id="1"]
[ext_resource type="Texture2D" path="res://art/items.png" id="2"]

[sub_resource type="AtlasTexture" id="icon"]
atlas = ExtResource("2")
region = Rect2(16, 0, 16, 16)

[resource]
script = ExtResource("1")
id = &"potion"
display_name = "红药水"
description = "回复两颗心。"
icon = SubResource("icon")
max_stack = 5
heal = 4

class Slot:
	var item: ItemData   # 共享、只读
	var count := 0       # 每格自己的状态

	func _init(i: ItemData, n: int) -> void:
		item = i
		count = n

## 放入物品，先叠加到同类格子，再放进空格。返回放不下的数量。
func add(item: ItemData, amount := 1) -> int:
	for s in slots:
		if amount > 0 and s != null and s.item.id == item.id and s.count < item.max_stack:
			var n := mini(amount, item.max_stack - s.count)
			s.count += n
			amount -= n
	for i in SIZE:
		if amount > 0 and slots[i] == null:
			var n := mini(amount, item.max_stack)
			slots[i] = Slot.new(item, n)
			amount -= n
	changed.emit()
	return amount

func take_damage_wrong(amount: int) -> void:
	# 错误：data 是所有史莱姆共享的同一个对象，这一刀砍在了"全体史莱姆"身上
	data.hp -= amount

func _ready() -> void:
	# 修法一：拿到资源后复制一份私有的。duplicate() 默认是浅复制，
	# 资源里如果还嵌着别的资源（数组、子资源），要用 duplicate(true) 或 duplicate_deep()
	data = data.duplicate()
	data.hp = data.max_hp

# 修法二（更推荐）：资源只放不会变的数据，会变的状态放在节点自己身上
var hp := 0


func setup() -> void:
	hp = data.max_hp


func take_damage(amount: int) -> void:
	hp -= amount

func _use_selected() -> void:
	var slot: Inventory.Slot = Game.inventory.slots[_selected]
	if slot == null:
		return
	if slot.item.heal <= 0:
		_desc.text = "%s 不能直接使用。" % slot.item.display_name
		return
	if Game.hp >= Game.max_hp:
		_desc.text = "血是满的，先留着吧。"
		return
	Game.change_hp(slot.item.heal)
	Game.inventory.remove_at(_selected)     # 只改这一格的数量，ItemData 本身不动

## enemies 是场上每只敌人的 {"kind", "x", "y", "hp"}，由主场景收集后传进来。
func save_game(player_pos: Vector2, enemies: Array = []) -> bool:
	var data := {
		"version": 1,
		"player": {"x": player_pos.x, "y": player_pos.y, "hp": hp, "max_hp": max_hp},  # Vector2 不能直接进 JSON
		"enemies": enemies,
		"coins": coins,
		"inventory": inventory.to_save(),
		"flags": flags,
		"slimes_killed": slimes_killed,
		"opened_chests": opened_chests,
	}
	var file := FileAccess.open(SAVE_PATH, FileAccess.WRITE)
	if file == null:
		push_error("存档失败：%s" % error_string(FileAccess.get_open_error()))
		return false
	file.store_string(JSON.stringify(data, "\t"))
	file.close()
	if OS.has_feature("web"):
		JavaScriptBridge.force_fs_sync()   # Web 上 user:// 在 IndexedDB 里，立刻同步一次
	return true

## 读档成功返回 {"x":..,"y":..} 形式的玩家数据，另外 "enemies" 里是存档时场上的敌人；
## 没有存档或格式不对返回空字典。
func load_game() -> Dictionary:
	if not FileAccess.file_exists(SAVE_PATH):
		return {}
	var data: Variant = JSON.parse_string(FileAccess.get_file_as_string(SAVE_PATH))
	if typeof(data) != TYPE_DICTIONARY or int(data.get("version", 0)) != 1:
		push_warning("存档格式不对，忽略")
		return {}
	var p: Dictionary = data["player"]
	max_hp = int(p["max_hp"])          # JSON 里的数字读回来都是 float，要转回 int
	hp = int(p["hp"])
	coins = int(data["coins"])
	inventory.from_save(data["inventory"], ITEMS)
	flags = data["flags"]
	slimes_killed = int(data["slimes_killed"])
	opened_chests.assign(data["opened_chests"])
	_emit_all()
	loaded.emit()
	p["enemies"] = data.get("enemies", [])   # 老存档没有这一项
	return p

func _enemies_to_save() -> Array:
	var out := []
	for e: Enemy in get_tree().get_nodes_in_group("enemies"):
		if e.hp > 0:                       # 正在播死亡动画的不存
			out.append({"kind": str(e.kind), "x": e.global_position.x, "y": e.global_position.y, "hp": e.hp})
	return out


func _restore_enemies(list: Array) -> void:
	for e in get_tree().get_nodes_in_group("enemies"):
		e.remove_from_group("enemies")     # 先移出分组：queue_free 要到帧末才真正删除
		e.queue_free()
	for d: Dictionary in list:
		var enemy: Enemy = (BAT if d["kind"] == "bat" else SLIME).instantiate()
		enemy.position = Vector2(d["x"], d["y"])
		world.add_child(enemy)
		enemy.hp = int(d["hp"])

func save_with_resource(pos: Vector2) -> void:
	var data := SaveData.new()
	data.player_position = pos
	data.hp = Game.hp
	data.coins = Game.coins
	data.flags = Game.flags.duplicate()
	var err := ResourceSaver.save(data, PATH)
	if err != OK:
		push_error("存档失败：%s" % error_string(err))


func load_with_resource() -> SaveData:
	if not ResourceLoader.exists(PATH):
		return null
	# CACHE_MODE_IGNORE：不要拿缓存里的旧对象，每次都从文件重新读
	return ResourceLoader.load(PATH, "", ResourceLoader.CACHE_MODE_IGNORE) as SaveData

func where_is_user_dir() -> void:
	# Windows: %APPDATA%\Godot\app_userdata\<项目名>
	# macOS:   ~/Library/Application Support/Godot/app_userdata/<项目名>
	# Linux:   ~/.local/share/godot/app_userdata/<项目名>
	# Web:     浏览器 IndexedDB 里的 /userfs（清除网站数据就没了）
	print(OS.get_user_data_dir())
	print(ProjectSettings.globalize_path("user://save.json"))