FPS（上）：第一人称控制器

[node name="Player" type="CharacterBody3D" groups=["player"]]
collision_layer = 2
collision_mask = 5
floor_snap_length = 0.3
script = ExtResource("1")

[node name="CollisionShape3D" type="CollisionShape3D" parent="."]
position = Vector3(0, 0.9, 0)
shape = SubResource("capsule")

[node name="Head" type="Node3D" parent="."]
position = Vector3(0, 1.62, 0)

[node name="Camera3D" type="Camera3D" parent="Head"]
current = true
fov = 75.0
near = 0.03
far = 250.0

[node name="AimRay" type="RayCast3D" parent="Head/Camera3D"]
enabled = false
target_position = Vector3(0, 0, -100)
collision_mask = 5

[node name="Weapons" type="Node3D" parent="Head/Camera3D"]
script = ExtResource("2")
weapons = Array[ExtResource("7")]([ExtResource("3"), ExtResource("4")])

[node name="Rifle" parent="Head/Camera3D/Weapons" instance=ExtResource("5")]
transform = Transform3D(0.7, 0, 0, 0, 0.7, 0, 0, 0, 0.7, 0.16, -0.15, -0.3)

[node name="Shotgun" parent="Head/Camera3D/Weapons" instance=ExtResource("6")]
visible = false
transform = Transform3D(0.7, 0, 0, 0, 0.7, 0, 0, 0, 0.7, 0.16, -0.16, -0.28)

func _unhandled_input(event: InputEvent) -> void:
	if event is InputEventMouseMotion and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:
		# screen_relative 是鼠标在屏幕上实际移动的像素，不受窗口拉伸（stretch）影响，适合做视角
		_look(event.screen_relative)


## 鼠标和触屏共用：relative 是移动了多少像素。
func _look(relative: Vector2) -> void:
	var d := relative * deg_to_rad(mouse_sensitivity)
	rotate_y(-d.x)                                  # 身体左右转（偏航 yaw）
	var pitch_dir := 1.0 if invert_y else -1.0
	head.rotation.x = clampf(head.rotation.x + d.y * pitch_dir,
			-deg_to_rad(max_pitch), deg_to_rad(max_pitch))   # 头上下看（俯仰 pitch），限制角度

## Web 上的鼠标锁定（Pointer Lock）有两条规则：
##   1. 必须在用户点击 / 按键的处理过程中请求，否则浏览器直接拒绝；
##   2. 用户按 Esc 时浏览器自己解除锁定，游戏往往收不到这个 Esc。
## 所以：点击提示层时请求锁定；之后每帧检查锁定状态，"锁过又丢了"就暂停。
## 手机上没有鼠标锁定：网页一打开触屏按键，游戏就直接开始，视角改由右半屏滑动控制。
func _on_touch_mode(on: bool) -> void:
	if on and not _running:
		_set_running(true)


func _on_overlay_clicked() -> void:
	capture_mouse()
	_set_running(true)


## 请求锁定鼠标。Web 版的输入事件是在浏览器的点击回调里同步处理的，所以这里仍算"用户手势"。
## Godot 自带的实现在锁定失败时（比如窗口没有焦点）会留下一条未捕获的 Promise 错误，
## 所以 Web 上自己调用 requestPointerLock() 并把失败吞掉；锁定成功后 Input.mouse_mode 会读到 CAPTURED。
func capture_mouse() -> void:
	if OS.has_feature("web"):
		JavaScriptBridge.eval("""(function () {
			var c = document.getElementById('canvas');
			var p = c && c.requestPointerLock ? c.requestPointerLock() : null;
			if (p && p.catch) p.catch(function () {});
		})()""")
	else:
		Input.mouse_mode = Input.MOUSE_MODE_CAPTURED


func _process(_delta: float) -> void:
	var captured := Input.mouse_mode == Input.MOUSE_MODE_CAPTURED
	if Tuning.touch_mode:
		hud.set_hint("")                                 # 手机上用虚拟按键，不需要锁定鼠标
	elif captured:
		_had_capture = true
		hud.set_hint("")
	elif _running and _had_capture:
		_had_capture = false
		_set_running(false)
		overlay.show_paused()
	elif _running and not _dev_mode:
		# 锁定没成功（比如无头浏览器、或者刚按过 Esc 浏览器还在冷却）：游戏照常运行，提示再点一次
		hud.set_hint("鼠标未锁定：点一下画面即可用鼠标转视角")
	if Engine.get_process_frames() == _flash_frame:
		weapons.models[weapons.current].flash()
	Tuning.stat("FPS", Engine.get_frames_per_second())
	Tuning.stat("敌人", spawner.alive().size())
	Tuning.stat("击杀", kills)
	# 渲染统计：每帧的绘制调用次数和三角形数，是判断 Web 版性能的两个主要指标
	Tuning.stat("绘制调用", RenderingServer.get_rendering_info(RenderingServer.RENDERING_INFO_TOTAL_DRAW_CALLS_IN_FRAME))
	Tuning.stat("三角形", RenderingServer.get_rendering_info(RenderingServer.RENDERING_INFO_TOTAL_PRIMITIVES_IN_FRAME))


func _unhandled_input(event: InputEvent) -> void:
	if event.is_action_pressed("ui_cancel") and Input.mouse_mode == Input.MOUSE_MODE_CAPTURED:
		Input.mouse_mode = Input.MOUSE_MODE_VISIBLE      # 桌面版：Esc 释放鼠标（下一帧会进入暂停）
	elif _running and event is InputEventMouseButton and event.pressed and not Tuning.touch_mode \
			and Input.mouse_mode != Input.MOUSE_MODE_CAPTURED:
		capture_mouse()                                  # 运行中但没锁定：这次点击用来重新锁定，不开火
		weapons.block_trigger()


func _set_running(on: bool) -> void:
	_running = on
	get_tree().paused = not on
	overlay.visible = not on
	if on:
		weapons.block_trigger()

func _move(delta: float) -> void:
	var input := Input.get_vector("move_left", "move_right", "move_forward", "move_back")
	# input 是"相对自己"的方向：x 左右，y 前后（前 = -1）。乘上身体的 basis 就变成世界方向。
	# Godot 里 -Z 是前方，所以"前"对应 Vector3(0, 0, -1)。
	var wish_dir := (transform.basis * Vector3(input.x, 0.0, input.y)).normalized()
	_sprinting = Input.is_action_pressed("sprint") and input.y < -0.1 and not _crouching
	var speed := walk_speed
	if _sprinting:
		speed *= sprint_mult
	elif _crouching:
		speed *= crouch_mult

	var horizontal := Vector3(velocity.x, 0.0, velocity.z)
	var rate: float
	if is_on_floor():
		rate = acceleration if wish_dir != Vector3.ZERO else friction
	else:
		# 空中：只有一部分操控力，没有输入时保持惯性（没有地面摩擦）
		rate = acceleration * air_control if wish_dir != Vector3.ZERO else 0.0
	# move_toward：每帧朝目标速度最多改变 rate·delta，相当于恒定加速度
	horizontal = horizontal.move_toward(wish_dir * speed, rate * delta)
	velocity.x = horizontal.x
	velocity.z = horizontal.z
	_tilt = -input.x

func _apply_gravity_and_jump(delta: float) -> void:
	if not is_on_floor():
		velocity.y -= gravity * delta
	elif Input.is_action_just_pressed("jump") and not _crouching:
		# 跳跃高度 h = v² / (2g)：默认 5.2² / 28 ≈ 0.97 米，跳不上 1.2 米高的箱子，但能跳上 0.9 米的台子
		velocity.y = jump_velocity

func _update_crouch(delta: float) -> void:
	var want := Input.is_action_pressed("crouch")
	if want and not _crouching:
		_set_body_height(CROUCH_HEIGHT)
		_crouching = true
	elif not want and _crouching and _can_stand_up():
		_set_body_height(STAND_HEIGHT)
		_crouching = false
	# 碰撞体是瞬间变矮的，眼睛高度则平滑地跟过去
	var eye := (CROUCH_HEIGHT if _crouching else STAND_HEIGHT) - EYE_BELOW_TOP
	head.position.y = lerpf(head.position.y, eye, 1.0 - exp(-12.0 * delta))


## 头顶检测：拿当前（蹲着的）碰撞体，"假装"往上挪一段，看会不会撞到东西。
## test_move 不会真的移动角色，只返回会不会发生碰撞。
func _can_stand_up() -> bool:
	return not test_move(global_transform, Vector3.UP * (STAND_HEIGHT - CROUCH_HEIGHT))


func _set_body_height(h: float) -> void:
	capsule.height = h
	collision.position.y = h / 2.0     # 脚底保持在原点，胶囊从上面缩短

func _update_head_bob(delta: float) -> void:
	var speed := Vector2(velocity.x, velocity.z).length()
	var target := Vector3.ZERO
	if is_on_floor() and speed > 0.5:
		# 相位按"走过的距离"增长：走得越快，晃得越快；停下时相位不变
		_bob_phase += speed * bob_freq * delta
		var amp := bob_amount * minf(speed / walk_speed, 1.6)
		# 横向走 1 个周期，纵向走 2 个周期（左右脚各落地一次）→ 轨迹是横放的 8 字
		target = Vector3(sin(_bob_phase) * amp * 0.6, sin(_bob_phase * 2.0) * amp, 0.0)
	# 帧率无关的平滑：系数 1 - exp(-k·dt)，不管 30 帧还是 144 帧，过渡快慢都一样
	_bob_offset = _bob_offset.lerp(target, 1.0 - exp(-10.0 * delta))

func _update_fov(delta: float) -> void:
	var moving_fast := Vector2(velocity.x, velocity.z).length() > walk_speed * 1.1
	var target := sprint_fov if (_sprinting and moving_fast) else fov
	camera.fov = lerpf(camera.fov, target, 1.0 - exp(-8.0 * delta))

func _on_landed(fall_speed: float) -> void:
	# 落得越快，镜头往下沉得越多（最多 0.3 米）
	_land_target = -clampf((fall_speed - 2.0) * 0.035, 0.0, 0.3)


func _update_camera(delta: float) -> void:
	_update_head_bob(delta)
	# 两级平滑：目标值先"弹"出去再慢慢回零，实际值快速追目标。这样有冲击感又不生硬。
	_land_offset = lerpf(_land_offset, _land_target, 1.0 - exp(-25.0 * delta))
	_land_target = lerpf(_land_target, 0.0, 1.0 - exp(-7.0 * delta))
	_recoil = _recoil.lerp(_recoil_target, 1.0 - exp(-30.0 * delta))
	_recoil_target = _recoil_target.lerp(Vector2.ZERO, 1.0 - exp(-6.0 * delta))
	camera.position = _bob_offset + Vector3(0.0, _land_offset, 0.0)
	camera.rotation.x = _recoil.x
	camera.rotation.y = _recoil.y
	camera.rotation.z = lerpf(camera.rotation.z, _tilt * deg_to_rad(1.5), 1.0 - exp(-8.0 * delta))
	_update_fov(delta)