# 通过代码操作场景树
func _ready() -> void:
    # 获取场景树根节点
    var tree = get_tree()
    
    # 获取当前场景根节点
    var current_scene = tree.current_scene
    print("当前场景: %s" % current_scene.name)
    
    # 获取节点数量
    var node_count = current_scene.get_child_count()
    print("子节点数量: %d" % node_count)
    
    # 遍历场景树
    print_tree()

# 使用 @export 让变量在检查器中可见
extends Sprite2D

@export var move_speed: float = 200.0
@export var health: int = 100
@export var sprite_texture: Texture2D
@export var enemy_color: Color = Color.RED

# 分组导出
@export_group("Movement")
@export var max_speed: float = 300.0
@export var acceleration: float = 50.0
@export var friction: float = 0.1

@export_group("Combat")
@export var attack_damage: int = 25
@export var attack_range: float = 50.0

# 子分组
@export_group("Advanced")
@export_subgroup("Physics")
@export var gravity_scale: float = 1.0
@export var bounce_factor: float = 0.5

# 代码中的 2D 变换
extends Node2D

func _ready() -> void:
    # 位置
    position = Vector2(100, 200)
    
    # 旋转（弧度）
    rotation = deg_to_rad(45)
    
    # 缩放
    scale = Vector2(2, 2)
    
    # 全局变换
    global_position = Vector2(500, 300)
    
    # 使用 Transform2D
    var transform = Transform2D(deg_to_rad(30), Vector2(200, 100))

# 调试工具函数
func _ready() -> void:
    # 打印调试信息
    print("节点路径: %s" % get_path())
    print("场景树: %s" % str(get_tree().root))
    
    # 断言（调试模式下生效）
    assert(health > 0, "生命值必须大于 0")
    
    # 条件断点：在脚本编辑器中点击行号左侧设置断点
    # 右键断点可以设置条件，例如：health < 50

    # 推送错误/警告到调试控制台
    push_warning("这是一个警告")
    push_error("这是一个错误")

    # 性能监控
    print("FPS: %d" % Performance.get_monitor(Performance.TIME_FPS))
    print("对象数量: %d" % Performance.get_monitor(Performance.OBJECT_COUNT))
    print("内存: %d MB" % (Performance.get_monitor(Performance.MEMORY_STATIC) / 1048576))

# AnimationPlayer 使用示例
extends CharacterBody2D

@onready var anim_player: AnimationPlayer = $AnimationPlayer
@onready var sprite: Sprite2D = $Sprite2D

var is_attacking: bool = false

func play_animation(anim_name: String) -> void:
    if anim_player.has_animation(anim_name):
        anim_player.play(anim_name)

func attack() -> void:
    if is_attacking:
        return
    is_attacking = true
    anim_player.play("attack")
    await anim_player.animation_finished
    is_attacking = false

func _physics_process(delta: float) -> void:
    if is_attacking:
        return
    
    if velocity.length() > 0:
        play_animation("run")
    else:
        play_animation("idle")

# TileMapLayer 使用示例（Godot 4.3+推荐）
extends TileMapLayer

# 地图尺寸
const MAP_WIDTH: int = 50
const MAP_HEIGHT: int = 30

func _ready() -> void:
    generate_random_map()

func generate_random_map() -> void:
    for x in range(MAP_WIDTH):
        for y in range(MAP_HEIGHT):
            var tile_id: int
            if y > MAP_HEIGHT * 0.7:
                tile_id = 1  # 地面
            elif y > MAP_HEIGHT * 0.5:
                tile_id = 2  # 草地
            else:
                tile_id = 0  # 空气
            
            set_cell(Vector2i(x, y), tile_id, Vector2i.ZERO)

func get_tile_at(world_pos: Vector2) -> Vector2i:
    return local_to_map(to_local(world_pos))

func set_tile_at(world_pos: Vector2, tile_id: int) -> void:
    var map_pos = local_to_map(to_local(world_pos))
    set_cell(map_pos, tile_id, Vector2i.ZERO)

# 代码方式连接信号
extends Node2D

@onready var button: Button = $Button
@onready var timer: Timer = $Timer
@onready var area: Area2D = $Area2D

func _ready() -> void:
    # 新语法：使用 Callable
    button.pressed.connect(_on_button_pressed)
    timer.timeout.connect(_on_timer_timeout)
    area.body_entered.connect(_on_area_body_entered)
    
    # 带参数的信号
    area.body_entered.connect(_on_body_entered_with_arg.bind("敌人区域"))

func _on_button_pressed() -> void:
    print("按钮被点击")

func _on_timer_timeout() -> void:
    print("定时器超时")

func _on_area_body_entered(body: Node2D) -> void:
    print("物体进入: %s" % body.name)

func _on_body_entered_with_arg(body: Node2D, area_name: String) -> void:
    print("%s 进入了 %s" % [body.name, area_name])

# 使用 @tool 脚本在编辑器中实时预览
@tool
extends Node2D

# 在编辑器中显示自定义绘制
@export var room_size: Vector2 = Vector2(320, 240):
    set(value):
        room_size = value
        queue_redraw()

@export var room_color: Color = Color(0.2, 0.3, 0.5, 0.5):
    set(value):
        room_color = value
        queue_redraw()

@export var show_grid: bool = true:
    set(value):
        show_grid = value
        queue_redraw()

func _draw() -> void:
    # 只在编辑器中绘制
    if not Engine.is_editor_hint():
        return
    
    # 绘制房间轮廓
    draw_rect(Rect2(-room_size / 2, room_size), room_color)
    draw_rect(Rect2(-room_size / 2, room_size), Color.WHITE, false, 2.0)
    
    # 绘制网格
    if show_grid:
        var grid_step = 32.0
        for x in range(-room_size.x / 2, room_size.x / 2, grid_step):
            var from = Vector2(x, -room_size.y / 2)
            var to = Vector2(x, room_size.y / 2)
            draw_line(from, to, Color(1, 1, 1, 0.1))
        for y in range(-room_size.y / 2, room_size.y / 2, grid_step):
            var from = Vector2(-room_size.x / 2, y)
            var to = Vector2(room_size.x / 2, y)
            draw_line(from, to, Color(1, 1, 1, 0.1))
    
    # 绘制门标记
    draw_circle(Vector2(0, -room_size.y / 2), 8, Color.GREEN)
    draw_circle(Vector2(0, room_size.y / 2), 8, Color.GREEN)