extends Node2D

func _init() -> void:
    print("[_init] 构造函数 - 节点对象已创建")

func _enter_tree() -> void:
    print("[_enter_tree] 进入场景树 - path: ", get_path())

func _ready() -> void:
    print("[_ready] 就绪 - 所有子节点已初始化")
    print("  子节点数量: ", get_child_count())
    print("  树中的路径: ", get_path())

func _process(delta: float) -> void:
    pass  # 每帧调用（不建议在生命周期学习时开启）

func _exit_tree() -> void:
    print("[_exit_tree] 离开场景树")

func _notification(what: int) -> void:
    match what:
        NOTIFICATION_ENTER_TREE:
            pass  # 与 _enter_tree 相同时机
        NOTIFICATION_READY:
            pass  # 与 _ready 相同时机
        NOTIFICATION_EXIT_TREE:
            pass  # 与 _exit_tree 相同时机
        NOTIFICATION_PAUSED:
            print("游戏暂停")
        NOTIFICATION_UNPAUSED:
            print("游戏恢复")

# 假设场景树:
# A
# ├── B
# │   └── D
# └── C

# _ready 执行顺序: D → B → C → A
# 从最深的子节点开始，由下往上执行
# 这保证了 _ready 中访问子节点时，子节点已就绪

extends Node2D

var enemy_scene = preload("res://scenes/Enemy.tscn")

func spawn_enemy(pos: Vector2) -> void:
    var enemy = enemy_scene.instance()
    enemy.position = pos
    add_child(enemy)  # 将 enemy 添加为当前节点的子节点

func spawn_bullet(pos: Vector2, direction: Vector2) -> void:
    var bullet = preload("res://scenes/Bullet.tscn").instance()
    bullet.position = pos
    bullet.direction = direction
    $Bullets.add_child(bullet)  # 添加到 Bullets 子节点下

# 方式一：直接释放
func remove_all_enemies() -> void:
    for enemy in $Enemies.get_children():
        $Enemies.remove_child(enemy)  # 从树中移除
        enemy.queue_free()            # 释放内存

# 方式二：queue_free（推荐）
func remove_enemy(enemy: Node) -> void:
    enemy.queue_free()  # 在当前帧结束后自动移除并释放

# 方式三：立即释放（不推荐，可能导致问题）
func immediate_remove() -> void:
    $Enemy.free()  # 立即释放，可能在回调中出问题

# 预加载场景资源
var enemy_scene = preload("res://scenes/Enemy.tscn")

# 实例化场景
func spawn(pos: Vector2) -> void:
    var instance = enemy_scene.instance()  # 创建实例
    instance.position = pos
    add_child(instance)

# 动态加载场景
func spawn_from_path(path: String, pos: Vector2) -> void:
    var scene = load(path)
    if scene:
        var instance = scene.instance()
        instance.position = pos
        add_child(instance)

# Enemy.gd
extends KinematicBody2D

var enemy_type: String = ""
var level: int = 1

func init(type: String, lvl: int) -> void:
    enemy_type = type
    level = lvl
    _apply_type_settings()

func _apply_type_settings() -> void:
    match enemy_type:
        "slime":
            health = 50
            speed = 100
        "goblin":
            health = 80
            speed = 150
        "dragon":
            health = 500
            speed = 80

# 生成时
var enemy = enemy_scene.instance()
enemy.init("dragon", 5)
add_child(enemy)

# 添加节点到组
$Player.add_to_group("players")
$Enemy.add_to_group("enemies")
$Enemy.add_to_group("damageable")

# 移除节点从组
$Enemy.remove_from_group("enemies")

# 检查节点是否在组中
if $Enemy.is_in_group("enemies"):
    print("是敌人")

# 获取组内所有节点
var enemies = get_tree().get_nodes_in_group("enemies")
print("敌人数量: ", enemies.size())

# 遍历敌人
for enemy in get_tree().get_nodes_in_group("enemies"):
    enemy.take_damage(10)

# 对组内所有节点调用方法
get_tree().call_group("enemies", "take_damage", 50)
get_tree().call_group("players", "heal", 20)

# 延迟调用（当前帧结束后）
get_tree().call_group_flags(
    SceneTree.GROUP_CALL_DEFERRED,
    "enemies",
    "set_active",
    false
)

# 敌人生成器
extends Node

func _ready() -> void:
    # 将所有敌人加入组
    for child in get_children():
        child.add_to_group("enemies")

# 伤害区域
extends Area2D

func _on_body_entered(body: Node) -> void:
    if body.is_in_group("damageable"):
        body.take_damage(25)
    if body.is_in_group("players"):
        body.collect_item()

# 存档系统
func save_all_enemies() -> Array:
    var data = []
    for enemy in get_tree().get_nodes_in_group("enemies"):
        data.append({
            "type": enemy.enemy_type,
            "position": enemy.global_position,
            "health": enemy.health,
        })
    return data

# 适合：松耦合、跨场景通信
# Player.gd
signal health_changed(value)

func take_damage(amount: int) -> void:
    health -= amount
    emit_signal("health_changed", health)

# UI.gd（连接 Player 的信号）
$Player.connect("health_changed", self, "_update_health_bar")

# 适合：紧耦合、父子关系
# Player.gd
func attack() -> void:
    $Weapon.fire()  # 直接调用子节点方法

# 跨节点调用
func _on_hit(damage: int) -> void:
    var game = get_node("/root/Main")
    game.on_player_hit(damage)

# 适合：广播消息
# 通知所有敌人玩家已死亡
get_tree().call_group("enemies", "on_player_died")

# 暂停所有敌人
get_tree().call_group("enemies", "set_active", false)

# res://scripts/SceneManager.gd
extends Node

var current_scene: Node = null
var scene_history: Array = []

func _ready() -> void:
    var root = get_tree().get_root()
    current_scene = root.get_child(root.get_child_count() - 1)

func goto_scene(path: String) -> void:
    # 记录历史
    scene_history.append(current_scene.filename)
    
    # 延迟切换（确保安全）
    call_deferred("_deferred_goto_scene", path)

func _deferred_goto_scene(path: String) -> void:
    # 释放当前场景
    current_scene.free()
    
    # 加载新场景
    var new_scene = load(path).instance()
    get_tree().get_root().add_child(new_scene)
    get_tree().set_current_scene(new_scene)
    current_scene = new_scene

func go_back() -> void:
    if scene_history.size() > 0:
        var previous = scene_history.pop_back()
        goto_scene(previous)

func reload_scene() -> void:
    goto_scene(current_scene.filename)

# res://scripts/GameManager.gd
extends Node

enum GameState { MENU, PLAYING, PAUSED, GAME_OVER }

var state: int = GameState.MENU
var score: int = 0
var high_score: int = 0
var lives: int = 3
var current_level: int = 1

signal state_changed(new_state: int)
signal score_changed(new_score: int)

func change_state(new_state: int) -> void:
    state = new_state
    emit_signal("state_changed", new_state)
    
    match new_state:
        GameState.PLAYING:
            get_tree().paused = false
        GameState.PAUSED:
            get_tree().paused = true
        GameState.GAME_OVER:
            _check_high_score()

func add_score(points: int) -> void:
    score += points
    emit_signal("score_changed", score)

func lose_life() -> void:
    lives -= 1
    if lives <= 0:
        change_state(GameState.GAME_OVER)

func reset_game() -> void:
    score = 0
    lives = 3
    current_level = 1
    change_state(GameState.PLAYING)

func _check_high_score() -> void:
    if score > high_score:
        high_score = score

extends Node2D

var chunk_scene = preload("res://scenes/MapChunk.tscn")
var chunk_size: float = 512.0
var active_chunks: Dictionary = {}
var render_distance: int = 3

func _process(delta: float) -> void:
    var player_chunk = _get_chunk_coord($Player.position)
    _update_chunks(player_chunk)

func _get_chunk_coord(pos: Vector2) -> Vector2:
    return Vector2(
        floor(pos.x / chunk_size),
        floor(pos.y / chunk_size)
    )

func _update_chunks(center: Vector2) -> void:
    # 需要加载的区块
    var needed_chunks = {}
    for x in range(-render_distance, render_distance + 1):
        for y in range(-render_distance, render_distance + 1):
            var coord = center + Vector2(x, y)
            needed_chunks[coord] = true
    
    # 加载新区块
    for coord in needed_chunks:
        if not active_chunks.has(coord):
            _load_chunk(coord)
    
    # 卸载远处区块
    for coord in active_chunks.keys():
        if not needed_chunks.has(coord):
            _unload_chunk(coord)

func _load_chunk(coord: Vector2) -> void:
    var chunk = chunk_scene.instance()
    chunk.position = coord * chunk_size
    chunk.init(coord)
    add_child(chunk)
    active_chunks[coord] = chunk

func _unload_chunk(coord: Vector2) -> void:
    active_chunks[coord].queue_free()
    active_chunks.erase(coord)