Godot Interactive System

玩家角色 (CharacterBase)
    │
    ├── Talk Area2D (collision_mask = 256) ← 交互检测区域
    │       │
    │       └── Area Entered/Exited Signals
    │
    └── try_interact() ← 按 "talk" 键触发
            │
            ├── talk_target.player_interact()  [NPC对话]
            │
            └── interactable_area.interact()   [关卡出口/商店]

@onready var talk: Area2D = $Body/talk
var talk_target = null
var interactable_area = null

collision_layer = 0         # 不作为碰撞层
collision_mask = 256        # 检测位于256层的交互对象
monitorable = false         # 不被其他 Area 检测

func _on_talk_area_entered(area: Area2D) -> void:
    if not area is InteractiveComponent:
        return
    if talk_target:
        talk_target.exit_interact(self)
        talk_target = null
    if area.has_method("enter_interact"):
        talk_target = area
        talk_target.enter_interact(self)

func _on_talk_area_exited(area: Area2D) -> void:
    if talk_target == area:
        talk_target.exit_interact(self)
        talk_target = null

func try_interact():
    if (not talk.has_overlapping_areas() or not talk_target) and not interactable_area:
        return
    if talk_target and talk_target.has_method("player_interact"):
        talk_target.player_interact(self)
        return
    if interactable_area:
        interactable_area.interact(self)
        return

class_name InteractiveComponent
extends Area2D

@export var agent: Node2D = null

func player_interact(player: CharacterBase):
    if not agent:
        return
    agent.player_interact(player)

func enter_interact(player: CharacterBase):
    if not agent:
        return
    agent.enter_interact(player)

func exit_interact(player: CharacterBase):
    if not agent:
        return
    agent.exit_interact(player)

collision_layer = 256
collision_mask = 0
monitoring = false

玩家交互请求
        ↓
InteractiveComponent.player_interact()
        ↓
agent.player_interact()

class_name NPCBase
extends CharacterBody2D

@export var interactable: bool = true
signal dialogue_started

func _physics_process(delta: float) -> void:
    if interactable:
        if can_talk_to_npc():
            if Input.is_action_just_pressed("talk"):
                if !interact_lock:
                    dialogue_in_progress = true
                    dialogue_started.emit()

class_name LevelExit
extends Area2D

func _on_body_entered(body: Node2D):
    if body is CharacterBase:
        body.position = Vector2(-10000, -10000)
        body.hide()
        LevelManager.call_deferred("change_scene",
            LevelManager.ChangeSceneParam.new(target_scene_path, target_scene_entry_tag))

class_name InteractableLevelExit
extends LevelExit

func interact(body):
    body.position = Vector2(-10000, -10000)
    body.hide()
    LevelManager.call_deferred("change_scene",
        LevelManager.ChangeSceneParam.new(target_scene_path, target_scene_entry_tag))

func player_interact(player: CharacterBase):
    var game_operation = handle_game_operation.bind(player)
    GameDirector.wait_game.connect(game_operation)
    GameDirector.load_chapter("res://chapters/store_test.json")
    await GameDirector.finished
    GameDirector.wait_game.disconnect(game_operation)

func enter_interact(player: CharacterBase):
    var interact_material := ShaderMaterial.new()
    interact_material.shader = load("res://resource/shaders/border.gdshader")
    interact_material.set_shader_parameter("outline_color", Color(1, 1, 1, 1))
    sprite_2d.material = interact_material

func exit_interact(_player: CharacterBase):
    sprite_2d.material = null

enum DoorState { CLOSED, OPEN_LEFT, OPEN_RIGHT }

func _on_left_in_body_entered(body: Node2D) -> void:
    if door_state == DoorState.CLOSED:
        door_state = DoorState.OPEN_RIGHT
        animated_sprite_2d.play("open_right")

可交互对象
    │
    ├── InteractiveComponent (collision_layer = 256)
    │       │
    │       └── agent: Node2D ← 实际处理逻辑的节点
    │
    ├── NPC (npc_base.gd)
    │
    ├── InteractableLevelExit (interactable_level_exit.gd)
    │
    └── Store (自定义 player_interact)