925236118/alphaagent/godot-ecs-component

┌─────────────────────────────────────────┐
│              Entity (Node)               │
│  - 角色节点、敌人节点、可交互对象          │
├─────────────────────────────────────────┤
│            Component (Node)              │
│  - HealthComponent、BuffComponent        │
│  - 可挂载到任意 Entity 上                 │
├─────────────────────────────────────────┤
│            Data (Resource)               │
│  - HealthData、WeaponData                │
│  - 可序列化、便于保存和复用               │
└─────────────────────────────────────────┘

# health_component.gd
class_name HealthComponent
extends Node
 
signal health_changed(current: int, maximum: int)
signal damaged(amount: int, source: Node)
signal healed(amount: int)
signal died
 
@export var max_health: int = 100
@export var invincibility_time: float = 0.0
 
var current_health: int:
    set(value):
        var old := current_health
        current_health = clampi(value, 0, max_health)
        if current_health != old:
            health_changed.emit(current_health, max_health)
 
var _invincible: bool = false
 
func _ready() -> void:
    current_health = max_health
 
func take_damage(amount: int, source: Node = null) -> int:
    if _invincible or current_health <= 0:
        return 0
 
    var actual := mini(amount, current_health)
    current_health -= actual
    damaged.emit(actual, source)
 
    if current_health <= 0:
        died.emit()
    elif invincibility_time > 0:
        _start_invincibility()
 
    return actual
 
func heal(amount: int) -> int:
    var actual := mini(amount, max_health - current_health)
    current_health += actual
    if actual > 0:
        healed.emit(actual)
    return actual
 
func _start_invincibility() -> void:
    _invincible = true
    await get_tree().create_timer(invincibility_time).timeout
    _invincible = false

# hitbox_component.gd
class_name HitboxComponent
extends Area2D
 
signal hit(hurtbox: HurtboxComponent)
 
@export var damage: int = 10
@export var knockback_force: float = 200.0
 
var owner_node: Node
 
func _ready() -> void:
    owner_node = get_parent()
    area_entered.connect(_on_area_entered)
 
func _on_area_entered(area: Area2D) -> void:
    if area is HurtboxComponent:
        var hurtbox := area as HurtboxComponent
        if hurtbox.owner_node != owner_node:
            hit.emit(hurtbox)
            hurtbox.receive_hit(self)

# hurtbox_component.gd
class_name HurtboxComponent
extends Area2D
 
signal hurt(hitbox: HitboxComponent)
 
@export var health_component: HealthComponent
 
var owner_node: Node
 
func _ready() -> void:
    owner_node = get_parent()
 
func receive_hit(hitbox: HitboxComponent) -> void:
    hurt.emit(hitbox)
 
    if health_component:
        health_component.take_damage(hitbox.damage, hitbox.owner_node)

Player (CharacterBody2D)
├── HealthComponent
│   └── (接收伤害，管理生命值)
├── HitboxComponent
│   └── (检测攻击，发送伤害)
├── HurtboxComponent
│   └── (接收伤害，触发健康组件)
├── BuffComponent
│   └── (管理增益/减益效果)
└── InventoryComponent
    └── (管理物品栏)

# weapon_data.gd
class_name WeaponData
extends Resource
 
@export var name: StringName
@export var damage: int
@export var attack_speed: float
@export var range: float
@export_multiline var description: String
@export var icon: Texture2D
@export var projectile_scene: PackedScene
@export var sound_attack: AudioStream

# character_stats.gd
class_name CharacterStats
extends Resource
 
signal stat_changed(stat_name: StringName, new_value: float)
 
@export var max_health: float = 100.0
@export var attack: float = 10.0
@export var defense: float = 5.0
@export var speed: float = 200.0
 
var _current_health: float
 
func _init() -> void:
    _current_health = max_health
 
func get_current_health() -> float:
    return _current_health
 
func take_damage(amount: float) -> float:
    var actual_damage := maxf(amount - defense, 1.0)
    _current_health = maxf(_current_health - actual_damage, 0.0)
    stat_changed.emit("health", _current_health)
    return actual_damage
 
func duplicate_for_runtime() -> CharacterStats:
    var copy := duplicate() as CharacterStats
    copy._current_health = copy.max_health
    return copy