动画、补间与手感

@export var animation := true        ## 角色动画（AnimationPlayer）
@export var squash := 1.0            ## 挤压拉伸强度，0 = 关
@export var particles := true        ## 粒子：烟尘、闪光、彩带
@export var shake := 1.0             ## 屏幕震动强度倍数，0 = 关
@export var hit_stop := 0.06         ## 命中停顿时长（秒），0 = 关

@export var foot_l := Vector2(-6, 12):
	set(v):
		foot_l = v
		queue_redraw()
@export var foot_r := Vector2(6, 12):
	set(v):
		foot_r = v
		queue_redraw()
@export_range(0.0, 1.0) var blink := 0.0:
	set(v):
		blink = v
		queue_redraw()
@export var sprout_angle := 0.0:
	set(v):
		sprout_angle = v
		queue_redraw()

[sub_resource type="Animation" id="Animation_run"]
resource_name = "run"
length = 0.4
loop_mode = 1
tracks/0/type = "value"
tracks/0/imported = false
tracks/0/enabled = true
tracks/0/path = NodePath("Visual/Flip/Rig:position")
tracks/0/interp = 1
tracks/0/loop_wrap = true
tracks/0/keys = {
"times": PackedFloat32Array(0, 0.1, 0.2, 0.3, 0.4),
"transitions": PackedFloat32Array(1, 1, 1, 1, 1),
"update": 0,
"values": [Vector2(0, -15), Vector2(0, -17.5), Vector2(0, -15), Vector2(0, -17.5), Vector2(0, -15)]
}

tracks/7/type = "method"
tracks/7/imported = false
tracks/7/enabled = true
tracks/7/path = NodePath(".")
tracks/7/interp = 1
tracks/7/loop_wrap = true
tracks/7/keys = {
"times": PackedFloat32Array(0, 0.2),
"transitions": PackedFloat32Array(1, 1),
"values": [{
"args": [],
"method": &"_footstep"
}, {
"args": [],
"method": &"_footstep"
}]
}

func _footstep() -> void:
	if is_on_floor():
		Fx.puff(global_position + Vector2(-facing * 6.0, 0), _dust_color(), 2, Vector2(-facing, -0.4))

func _update_visual(delta: float) -> void:
	if dead:
		return
	flip.scale.x = facing
	body.look = Vector2(facing * minf(absf(velocity.x) / max_speed, 1.0), clampf(velocity.y / 600.0, -1.0, 1.0))
	_happy_timer -= delta
	if _happy_timer > 0.0:
		body.expression = PlayerBody.Face.HAPPY
	elif velocity.y > max_fall_speed * 0.8:
		body.expression = PlayerBody.Face.SURPRISED
	else:
		body.expression = PlayerBody.Face.NORMAL

	if not Fx.animation:
		return
	var next := "idle"
	if not is_on_floor():
		next = "jump" if velocity.y < 0.0 else "fall"
	elif absf(velocity.x) > 20.0:
		next = "run"
	if anim.current_animation != next:
		anim.play(next, 0.08)
	# 跑步动画的播放速度跟着实际速度走，脚步才不会"打滑"
	anim.speed_scale = clampf(absf(velocity.x) / 220.0, 0.6, 1.8) if next == "run" else 1.0
	Tuning.stat("动画", next)

func chain_example() -> void:
	var tw := create_tween()                              # 补间绑定在这个节点上，节点被删除时自动停止
	tw.tween_property(self, "position:x", 300.0, 0.5)     # 第 1 步
	tw.tween_property(self, "rotation", PI, 0.3)          # 第 2 步：等第 1 步结束才开始
	tw.tween_interval(0.2)                                # 第 3 步：等 0.2 秒
	tw.tween_callback(queue_free)                         # 第 4 步：调用一个方法

func parallel_example() -> void:
	var tw := create_tween().set_parallel()               # 之后添加的步骤都同时开始
	tw.tween_property(self, "scale", Vector2(2, 2), 0.4)
	tw.tween_property(self, "modulate:a", 0.0, 0.4)
	tw.chain().tween_callback(queue_free)                 # chain()：这一步等前面全部结束

	# 另一种写法：默认按顺序，只让某一步和上一步同时进行
	var tw2 := create_tween()
	tw2.tween_property(self, "position:y", -40.0, 0.3).as_relative()
	tw2.parallel().tween_property(self, "rotation", 0.5, 0.3)

func _on_body_entered(body: Node2D) -> void:
	if _taken or not body is Player:
		return
	_taken = true
	body.collect_coin()
	Fx.sparkle(global_position, Color("#ffd84a"))
	set_deferred("monitoring", false)
	scale = Vector2.ONE
	# 并行：同时往上飘、放大、淡出；结束后删除自己
	var tw := create_tween().set_parallel()
	tw.tween_property(self, "position:y", position.y - 28.0, 0.35) \
			.set_trans(Tween.TRANS_CUBIC).set_ease(Tween.EASE_OUT)
	tw.tween_property(self, "scale", Vector2(1.6, 1.6), 0.35) \
			.set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)
	tw.tween_property(self, "modulate:a", 0.0, 0.2).set_delay(0.15)
	tw.chain().tween_callback(queue_free)

func ease_example() -> void:
	var tw := create_tween()
	tw.tween_property(self, "position:x", 400.0, 0.6) \
			.set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)     # 冲过头一点再退回来
	tw.tween_property(self, "position:x", 0.0, 0.6) \
			.set_trans(Tween.TRANS_BOUNCE).set_ease(Tween.EASE_OUT)   # 像球落地一样弹几下

## UI 弹跳：先瞬间放大，再用 ELASTIC 缓动弹回原大小。
## Control 默认绕左上角缩放，所以先把 pivot_offset 设到中心。
func pop(c: Control, amount := 1.6) -> void:
	c.pivot_offset = c.size / 2.0
	c.scale = Vector2(amount, amount)
	var tw := c.create_tween()
	tw.tween_property(c, "scale", Vector2.ONE, 0.5).set_trans(Tween.TRANS_ELASTIC).set_ease(Tween.EASE_OUT)

func loop_example() -> void:
	var tw := create_tween().set_loops()                  # 不传次数 = 无限循环
	tw.tween_property(self, "position:y", -6.0, 0.5).as_relative().set_trans(Tween.TRANS_SINE)
	tw.tween_property(self, "position:y", 6.0, 0.5).as_relative().set_trans(Tween.TRANS_SINE)


func await_example() -> void:
	var tw := create_tween()
	tw.tween_property(self, "modulate:a", 0.0, 0.5)
	await tw.finished                                     # 等补间播完再往下执行
	queue_free()

var _tween: Tween


func restart_tween() -> void:
	if _tween:
		_tween.kill()          # 先停掉旧的；两个补间同时改一个属性，结果会互相打架
	_tween = create_tween()
	_tween.tween_property(self, "scale", Vector2.ONE, 0.2).from(Vector2(1.3, 0.7))

## 挤压拉伸：先把 Visual 瞬间缩放到 to，再用 Tween 弹回 (1, 1)。
## Fx.squash 是强度：0 = 关闭，1 = 原样，2 = 加倍夸张。
func squash(to: Vector2, duration := 0.25) -> void:
	if Fx.squash <= 0.0:
		visual.scale = Vector2.ONE
		return
	if _squash_tween:
		_squash_tween.kill()
	visual.scale = Vector2.ONE.lerp(to, Fx.squash)
	_squash_tween = create_tween()
	_squash_tween.tween_property(visual, "scale", Vector2.ONE, duration) \
			.set_trans(Tween.TRANS_BACK).set_ease(Tween.EASE_OUT)

func _on_jumped() -> void:
	squash(Vector2(0.7, 1.35))
	Fx.puff(global_position, _dust_color(), 6, Vector2.UP)


func _on_landed() -> void:
	# 下落越快，压得越扁、烟尘越多
	var k := clampf(_fall_speed / max_fall_speed, 0.0, 1.0)
	squash(Vector2(1.0 + 0.45 * k, 1.0 - 0.4 * k))
	Fx.puff(global_position, _dust_color(), int(4 + 10 * k), Vector2.ZERO)
	if k > 0.85:
		Fx.add_trauma(0.25)

[node name="Dust" type="CPUParticles2D"]
emitting = false
amount = 8
lifetime = 0.45
one_shot = true
explosiveness = 1.0
randomness = 0.3
lifetime_randomness = 0.3
local_coords = false
texture = ExtResource("1")
emission_shape = 3
emission_rect_extents = Vector2(8, 1)
direction = Vector2(0, -1)
spread = 80.0
gravity = Vector2(0, -60)
initial_velocity_min = 40.0
initial_velocity_max = 110.0
damping_min = 120.0
damping_max = 200.0
scale_amount_min = 0.7
scale_amount_max = 1.4
scale_amount_curve = SubResource("Curve_size")
color_ramp = SubResource("Gradient_fade")

## 在 pos 处放一次性粒子：实例化场景 → 设置 → 加进场景树 → 播完自动删除。
func burst(scene: PackedScene, pos: Vector2, color: Color, amount: int, dir := Vector2.ZERO) -> void:
	if not particles or amount <= 0:
		return
	var p := scene.instantiate() as CPUParticles2D
	p.amount = amount
	p.color = color
	if dir != Vector2.ZERO:
		p.direction = dir
		p.spread = 30.0
	p.global_position = pos
	get_tree().current_scene.add_child(p)
	p.emitting = true
	p.finished.connect(p.queue_free)

## trauma（创伤值）模型：受击时累加 trauma（0~1），随时间线性衰减；
## 实际震动幅度 = trauma²，小冲击几乎不晃，大冲击晃得厉害，衰减也显得自然。
## 偏移用连续噪声而不是每帧随机数，画面是"晃"而不是"抖"。
func add_trauma(amount: float) -> void:
	trauma = minf(trauma + amount, 1.0)


func _update_shake(delta: float) -> void:
	trauma = maxf(trauma - trauma_decay * delta, 0.0)
	_time += delta * 30.0
	var s := trauma * trauma * Fx.shake
	offset = Vector2(
		max_offset.x * s * _noise.get_noise_2d(1.0, _time),
		max_offset.y * s * _noise.get_noise_2d(100.0, _time))
	rotation = max_roll * s * _noise.get_noise_2d(200.0, _time)
	Tuning.stat("trauma", snappedf(trauma, 0.01))

## 命中停顿：把整个游戏的时间流速压到接近 0，过一小会儿再恢复。
## 计时器的第 4 个参数 ignore_time_scale = true，否则它自己也会被"冻住"。
func freeze(duration: float) -> void:
	if duration <= 0.0:
		return
	_freeze_id += 1
	var id := _freeze_id
	Engine.time_scale = 0.05
	await get_tree().create_timer(duration, true, false, true).timeout
	if id == _freeze_id:      # 期间又触发了新的停顿，就让新的那次负责恢复
		Engine.time_scale = 1.0

func _on_hitbox_body_entered(body: Node2D) -> void:
	if _dead or not body is Player or body.dead:
		return
	var player := body as Player
	# 玩家正在下落，并且脚比史莱姆的上半身高 → 算"踩"。
	# 区域的 body_entered 信号会比真正接触晚一两个物理帧，所以判定线放得宽一点（身体中间偏下）。
	if player.velocity.y > 0.0 and player.global_position.y < global_position.y - 3.0:
		_squash_die()
		player.bounce()
	else:
		player.die()


func _squash_die() -> void:
	_dead = true
	set_deferred("collision_layer", 0)
	hitbox.set_deferred("monitoring", false)
	Fx.freeze(Fx.hit_stop)
	Fx.add_trauma(0.35)
	Fx.sparkle(global_position + Vector2(0, -10), Color("#b693ff"), 14)
	var tw := create_tween()
	tw.tween_property($Body, "scale", Vector2(1.6, 0.25), 0.08)
	tw.tween_interval(0.25)
	tw.tween_property($Body, "modulate:a", 0.0, 0.2)
	tw.tween_callback(queue_free)