# weapon_data.gd
class_name WeaponData
extends Resource

@export var weapon_name: String = "未命名武器"
@export var damage: int = 10
@export var attack_speed: float = 1.0
@export var range: float = 2.0
@export var icon: Texture2D
@export var attack_animation: StringName = &"attack"

@export_group("音效")
@export var swing_sound: AudioStream
@export var hit_sound: AudioStream
@export var crit_sound: AudioStream

@export_group("特殊效果")
@export var particle_effect: PackedScene
@export var status_effect: StatusEffect

func get_dps() -> float:
    return damage * attack_speed

func _to_string() -> String:
    return "WeaponData(%s, DMG:%d, SPD:%.1f)" % [weapon_name, damage, attack_speed]

# 使用自定义资源
var sword = preload("res://data/weapons/sword.tres")
print(sword.weapon_name)  # "铁剑"
print(sword.get_dps())    # 15.0

# armor_data.gd
class_name ArmorData
extends Resource

@export var armor_name: String
@export var defense: int
@export var slot: ArmorSlot

enum ArmorSlot { HEAD, CHEST, LEGS, FEET, HANDS }

# character_stats.gd
class_name CharacterStats
extends Resource

@export var base_health: int = 100
@export var base_attack: int = 10
@export var base_defense: int = 5

@export var equipped_weapon: WeaponData
@export var equipped_armor: Array[ArmorData] = []

@export var skills: Array[SkillData] = []

func get_total_defense() -> int:
    var total = base_defense
    for armor in equipped_armor:
        total += armor.defense
    return total

# preload — 编译时加载，脚本解析时就加载完成
# 适用于已知的、必定使用的资源
const SWORD_SCENE = preload("res://weapons/sword.tscn")
const TEXTURE_ATLAS = preload("res://sprites/atlas.webp")

# load — 运行时按需加载
# 适用于可选资源或延迟加载
func load_weapon(weapon_id: String):
    var path = "res://data/weapons/%s.tres" % weapon_id
    if ResourceLoader.exists(path):
        var weapon: WeaponData = load(path)
        return weapon
    return null

# ResourceLoader.load — 高级加载
func load_large_texture_async():
    var request_id = ResourceLoader.load_threaded_request(
        "res://textures/large_terrain.webp",
        "",  # type hint (可选)
        true  # use_sub_threads
    )

    # 轮询加载状态
    while true:
        var progress = []
        var status = ResourceLoader.load_threaded_get_status(
            "res://textures/large_terrain.webp", progress
        )

        if status == ResourceLoader.THREAD_LOAD_LOADED:
            var texture = ResourceLoader.load_threaded_get(
                "res://textures/large_terrain.webp"
            )
            return texture
        elif status == ResourceLoader.THREAD_LOAD_FAILED:
            push_error("资源加载失败")
            return null

        await get_tree().process_frame

# 保存自定义资源到文件
func save_game_data(data: SaveData, slot: int):
    var path = "user://saves/save_%d.tres" % slot
    var error = ResourceSaver.save(data, path)
    if error != OK:
        push_error("保存失败: " + error_string(error))
    else:
        print("保存成功: ", path)

# 加载存档
func load_game_data(slot: int) -> SaveData:
    var path = "user://saves/save_%d.tres" % slot
    if not ResourceLoader.exists(path):
        return null
    return ResourceLoader.load(path)

# 保存为 .res 格式（二进制，更小但不可读）
func save_binary(data: Resource, path: String):
    ResourceSaver.save(data, path, ResourceSaver.FLAG_COMPRESS)

# Godot 自动缓存已加载的资源
var texture1 = load("res://icon.svg")
var texture2 = load("res://icon.svg")
print(texture1 == texture2)  # true — 同一资源对象

# 清除缓存（慎用）
func clear_specific_resource(path: String):
    # 不直接支持清除单个资源缓存
    # 但可以通过以下方式强制重新加载
    var resource = ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_IGNORE)

# 检查资源是否被缓存
func is_cached(path: String) -> bool:
    return ResourceLoader.has_cached(path)

# 强制重新加载
func reload_resource(path: String) -> Resource:
    return ResourceLoader.load(path, "", ResourceLoader.CACHE_MODE_REPLACE)

# 动态生成纹理
func generate_gradient_texture(width: int, height: int,
    color_a: Color, color_b: Color) -> ImageTexture:

    var image = Image.create(width, height, false, Image.FORMAT_RGBA8)

    for y in range(height):
        for x in range(width):
            var t = float(x) / float(width)
            var color = color_a.lerp(color_b, t)
            image.set_pixel(x, y, color)

    var texture = ImageTexture.create_from_image(image)
    return texture

# 动态生成网格
func generate_terrain_mesh(heightmap: PackedFloat32Array,
    size: int, height_scale: float) -> ArrayMesh:

    var surface_tool = SurfaceTool.new()
    surface_tool.begin(Mesh.PRIMITIVE_TRIANGLES)

    for z in range(size - 1):
        for x in range(size - 1):
            var i0 = z * size + x
            var i1 = z * size + x + 1
            var i2 = (z + 1) * size + x
            var i3 = (z + 1) * size + x + 1

            var v0 = Vector3(x, heightmap[i0] * height_scale, z)
            var v1 = Vector3(x + 1, heightmap[i1] * height_scale, z)
            var v2 = Vector3(x, heightmap[i2] * height_scale, z + 1)
            var v3 = Vector3(x + 1, heightmap[i3] * height_scale, z + 1)

            # 三角形 1
            surface_tool.add_vertex(v0)
            surface_tool.add_vertex(v2)
            surface_tool.add_vertex(v1)

            # 三角形 2
            surface_tool.add_vertex(v1)
            surface_tool.add_vertex(v2)
            surface_tool.add_vertex(v3)

    surface_tool.generate_normals()
    surface_tool.generate_tangents()

    return surface_tool.commit()

# 动态生成音频
func generate_sine_wave(frequency: float, duration: float,
    sample_rate: int = 44100) -> AudioStreamWAV:

    var num_samples = int(sample_rate * duration)
    var data = PackedByteArray()

    for i in range(num_samples):
        var t = float(i) / float(sample_rate)
        var sample = sin(2.0 * PI * frequency * t)
        var sample_int = int(sample * 32767)

        # 16-bit PCM, little-endian
        data.append(sample_int & 0xFF)
        data.append((sample_int >> 8) & 0xFF)

    var stream = AudioStreamWAV.new()
    stream.format = AudioStreamWAV.FORMAT_16_BITS
    stream.mix_rate = sample_rate
    stream.stereo = false
    stream.data = data

    return stream

# 版本化资源格式
class_name VersionedResource
extends Resource

const CURRENT_VERSION = 3

@export var version: int = CURRENT_VERSION
@export var data: Dictionary = {}

# 自动迁移旧版本
func migrate():
    while version < CURRENT_VERSION:
        match version:
            1:
                # v1 → v2: 重命名字段
                if data.has("hp"):
                    data["health"] = data["hp"]
                    data.erase("hp")
                version = 2
            2:
                # v2 → v3: 新增字段
                if not data.has("mana"):
                    data["mana"] = 0
                version = 3

    print("资源已迁移到版本 ", CURRENT_VERSION)

# custom_importer.gd
@tool
extends EditorImportPlugin

func _get_importer_name() -> String:
    return "my_game.tileset"

func _get_visible_name() -> String:
    return "Tileset Data"

func _get_recognized_extensions() -> PackedStringArray:
    return PackedStringArray(["tileset"])

func _get_save_extension() -> String:
    return "tres"

func _get_resource_type() -> String:
    return "Resource"

func _get_preset_count() -> int:
    return 1

func _get_preset_name(preset_index: int) -> String:
    return "默认"

func _get_import_options(path: String, preset_index: int) -> Array[Dictionary]:
    return [
        {
            "name": "tile_size",
            "default_value": Vector2i(32, 32),
            "property_hint": PROPERTY_HINT_TYPE_STRING,
        },
        {
            "name": "auto_tile",
            "default_value": true,
        }
    ]

func _import(source_file: str, save_path: str, options: Dictionary,
    platform_variants: Array, gen_files: Array) -> Error:

    # 读取源文件
    var file = FileAccess.open(source_file, FileAccess.READ)
    if not file:
        return FileAccess.get_open_error()

    var json = JSON.new()
    var error = json.parse(file.get_as_text())
    if error != OK:
        return error

    var data = json.data

    # 创建资源
    var resource = TilesetData.new()
    resource.tile_size = options.get("tile_size", Vector2i(32, 32))
    resource.tiles = data.get("tiles", [])

    # 保存为 .tres
    return ResourceSaver.save(resource, save_path + ".tres")

# equipment_system.gd
extends Node

var equipped: Dictionary = {}  # slot -> EquipmentData
var inventory: Array[EquipmentData] = []

signal equipment_changed(slot: StringName, old_item: EquipmentData, new_item: EquipmentData)

func equip(item: EquipmentData) -> bool:
    var slot = item.slot_name
    var old = equipped.get(slot)

    equipped[slot] = item
    inventory.erase(item)

    if old:
        inventory.append(old)

    equipment_changed.emit(slot, old, item)
    return true

func unequip(slot: StringName) -> bool:
    if not equipped.has(slot):
        return false

    var item = equipped[slot]
    equipped.erase(slot)
    inventory.append(item)

    equipment_changed.emit(slot, item, null)
    return true

func get_total_stats() -> Dictionary:
    var stats = {"attack": 0, "defense": 0, "speed": 0}
    for item in equipped.values():
        stats.attack += item.attack_bonus
        stats.defense += item.defense_bonus
        stats.speed += item.speed_bonus
    return stats