925236118/alphaagent/godot-skill-upgrade

{
    "skills": [
        {
            "id": "fireball",
            "name": "火球术",
            "description": "发射一个火球攻击敌人",
            "icon": "res://icons/fireball.png",
            "type": "attack",
            "cost": {
                "mana": 30,
                "cooldown": 2.0
            },
            "unlock": {
                "level_required": 3,
                "skill_required": null,
                "item_required": null
            },
            "upgrade_levels": [
                {
                    "level": 1,
                    "damage": 50,
                    "range": 10.0
                },
                {
                    "level": 2,
                    "damage": 75,
                    "range": 12.0
                },
                {
                    "level": 3,
                    "damage": 100,
                    "range": 15.0
                }
            ]
        },
        {
            "id": "fire_mastery",
            "name": "火焰精通",
            "description": "火焰技能伤害提升15%",
            "icon": "res://icons/fire_mastery.png",
            "type": "passive",
            "cost": {
                "skill_points": 1
            },
            "unlock": {
                "level_required": 5,
                "skill_required": "fireball",
                "item_required": null
            },
            "upgrade_levels": [
                {
                    "level": 1,
                    "damage_bonus": 0.15
                },
                {
                    "level": 2,
                    "damage_bonus": 0.25
                }
            ]
        }
    ]
}

# skill_data.gd
class_name SkillData
extends Resource
 
## 技能唯一标识符
@export var id: StringName
 
## 技能显示名称
@export var skill_name: String
 
## 技能描述
@export_multiline var description: String
 
## 技能图标路径
@export var icon_path: String
 
## 技能类型
@export_enum("Attack", "Defense", "Support", "Passive", "Ultimate") var skill_type: int = 0
 
## 消耗
@export var mana_cost: float = 0.0
@export var cooldown: float = 0.0
@export var skill_points_cost: int = 0
 
## 解锁条件
@export var level_required: int = 1
@export var skill_required: StringName  # 前置技能ID
@export var item_required: StringName   # 所需物品ID
 
## 升级配置
@export var upgrade_levels: Array[Dictionary] = []
 
## 最大等级
var max_level: int:
    get: return upgrade_levels.size()
 
func get_upgrade_data(level: int) -> Dictionary:
    if level <= 0 or level > max_level:
        return {}
    return upgrade_levels[level - 1]
 
func can_unlock(player_level: int, unlocked_skills: Array, owned_items: Array) -> bool:
    # 检查等级
    if player_level < level_required:
        return false
    
    # 检查前置技能
    if skill_required != null and not skill_required in unlocked_skills:
        return false
    
    return true

# unlock_condition.gd
class_name UnlockCondition
extends RefCounted
 
enum ConditionType { LEVEL, SKILL, ITEM, QUEST }
 
var condition_type: ConditionType
var required_value: Variant
 
func _init(type: ConditionType, value: Variant) -> void:
    condition_type = type
    required_value = value
 
static func level_required(level: int) -> UnlockCondition:
    return UnlockCondition.new(ConditionType.LEVEL, level)
 
static func skill_required(skill_id: StringName) -> UnlockCondition:
    return UnlockCondition.new(ConditionType.SKILL, skill_id)
 
static func item_required(item_id: StringName) -> UnlockCondition:
    return UnlockCondition.new(ConditionType.ITEM, item_id)
 
func check(player: Player) -> bool:
    match condition_type:
        ConditionType.LEVEL:
            return player.level >= required_value
        ConditionType.SKILL:
            return player.skills.has(required_value)
        ConditionType.ITEM:
            return player.inventory.has_item(required_value)
    return false

# skill_unlock_manager.gd
class_name SkillUnlockManager
extends Node
 
## 可用技能列表
var available_skills: Array[SkillData] = []
 
## 已解锁技能字典
var unlocked_skills: Dictionary = {}
 
## 信号：技能解锁
signal skill_unlocked(skill_id: StringName)
 
## 信号：解锁条件变化
signal unlock_conditions_changed
 
func _ready() -> void:
    pass
 
func load_skills_from_json(json_path: String) -> void:
    var file := FileAccess.open(json_path, FileAccess.READ)
    if file == null:
        push_error("无法加载技能配置: ", json_path)
        return
    
    var json_str := file.get_as_text()
    file.close()
    
    var json := JSON.parse_string(json_str)
    if json == null or not json.has("skills"):
        return
    
    for skill_json in json.skills:
        var skill := _create_skill_data(skill_json)
        available_skills.append(skill)
 
func _create_skill_data(data: Dictionary) -> SkillData:
    var skill := SkillData.new()
    skill.id = data.get("id", "")
    skill.skill_name = data.get("name", "")
    skill.description = data.get("description", "")
    skill.icon_path = data.get("icon", "")
    skill.skill_type = data.get("type", "attack")
    skill.mana_cost = data.get("cost", {}).get("mana", 0)
    skill.cooldown = data.get("cost", {}).get("cooldown", 0)
    skill.skill_points_cost = data.get("cost", {}).get("skill_points", 0)
    skill.level_required = data.get("unlock", {}).get("level_required", 1)
    skill.skill_required = data.get("unlock", {}).get("skill_required")
    skill.item_required = data.get("unlock", {}).get("item_required")
    skill.upgrade_levels = data.get("upgrade_levels", [])
    
    return skill
 
func try_unlock_skill(skill_id: StringName, player: Player) -> bool:
    var skill := _get_skill_by_id(skill_id)
    if skill == null:
        return false
    
    # 检查是否已解锁
    if unlocked_skills.has(skill_id):
        return false
    
    # 检查解锁条件
    if not skill.can_unlock(player.level, unlocked_skills.keys(), []):
        return false
    
    # 解锁技能
    _unlock_skill(skill_id)
    return true
 
func _unlock_skill(skill_id: StringName) -> void:
    unlocked_skills[skill_id] = 1  # 等级1
    skill_unlocked.emit(skill_id)
 
func get_skill_level(skill_id: StringName) -> int:
    return unlocked_skills.get(skill_id, 0)
 
func can_upgrade_skill(skill_id: StringName) -> bool:
    if not unlocked_skills.has(skill_id):
        return false
    
    var skill := _get_skill_by_id(skill_id)
    if skill == null:
        return false
    
    var current_level := get_skill_level(skill_id)
    return current_level < skill.max_level
 
func upgrade_skill(skill_id: StringName, player: Player) -> bool:
    if not can_upgrade_skill(skill_id):
        return false
    
    var skill := _get_skill_by_id(skill_id)
    
    # 检查消耗
    if player.skill_points < skill.skill_points_cost:
        return false
    
    # 消耗资源
    player.skill_points -= skill.skill_points_cost
    
    # 升级
    unlocked_skills[skill_id] += 1
    return true
 
func _get_skill_by_id(skill_id: StringName) -> SkillData:
    for skill in available_skills:
        if skill.id == skill_id:
            return skill
    return null
 
func get_unlocked_skills() -> Array[SkillData]:
    var result: Array[SkillData] = []
    for skill in available_skills:
        if unlocked_skills.has(skill.id):
            result.append(skill)
    return result
 
func get_available_skills_for_player(player: Player) -> Array[SkillData]:
    var result: Array[SkillData] = []
    for skill in available_skills:
        if not unlocked_skills.has(skill.id) and skill.can_unlock(player.level, unlocked_skills.keys(), []):
            result.append(skill)
    return result

# experience_system.gd
class_name ExperienceSystem
extends Node
 
## 信号：升级
signal level_up(new_level: int)
 
## 信号：经验值变化
signal experience_changed(current: int, required: int)
 
@export var level_multiplier: float = 1.5
@export var base_exp: int = 100
 
var current_level: int = 1
var current_exp: int = 0
 
func _ready() -> void:
    pass
 
func get_required_exp(level: int) -> int:
    """获取指定等级所需经验值"""
    return int(base_exp * pow(level, level_multiplier))
 
func add_exp(amount: int) -> bool:
    current_exp += amount
    experience_changed.emit(current_exp, get_required_exp(current_level))
    
    while current_exp >= get_required_exp(current_level):
        current_exp -= get_required_exp(current_level)
        current_level += 1
        level_up.emit(current_level)
    
    return true
 
func get_exp_progress() -> float:
    var required := get_required_exp(current_level)
    return float(current_exp) / float(required) if required > 0 else 0.0

# skill_point_system.gd
class_name SkillPointSystem
extends Node
 
## 信号：技能点变化
signal skill_points_changed(points: int)
 
@export var base_points_per_level: int = 1
@export var bonus_points_from_quests: int = 0
 
var total_points: int = 0
var spent_points: int = 0
 
func _ready() -> void:
    pass
 
func grant_level_points() -> void:
    total_points += base_points_per_level
    skill_points_changed.emit(get_available_points())
 
func grant_bonus_points(amount: int) -> void:
    total_points += amount
    skill_points_changed.emit(get_available_points())
 
func spend_points(amount: int) -> bool:
    if amount > get_available_points():
        return false
    
    spent_points += amount
    skill_points_changed.emit(get_available_points())
    return true
 
func refund_points(amount: int) -> void:
    spent_points = maxi(spent_points - amount, 0)
    skill_points_changed.emit(get_available_points())
 
func get_available_points() -> int:
    return total_points - spent_points

# upgrade_trigger.gd
class_name UpgradeTrigger
extends Node
 
## 信号：触发升级
signal upgrade_triggered(upgrade_type: StringName, value: Variant)
 
func _ready() -> void:
    # 连接玩家等级变化
    var exp_system := ExperienceSystem
    exp_system.level_up.connect(_on_level_up)
 
func _on_level_up(new_level: int) -> void:
    upgrade_triggered.emit("level", new_level)
    
    # 给玩家技能点
    var point_system := SkillPointSystem
    point_system.grant_level_points()
    
    # 检查新技能解锁
    _check_new_skill_unlocks(new_level)
 
func _check_new_skill_unlocks(player_level: int) -> void:
    var unlock_manager := SkillUnlockManager
    var available := unlock_manager.get_available_skills_for_player(get_parent())
    
    for skill in available:
        if skill.level_required == player_level:
            unlock_manager.try_unlock_skill(skill.id, get_parent())
 
## 任务完成触发
func trigger_quest_complete(quest_id: StringName) -> void:
    upgrade_triggered.emit("quest", quest_id)
 
## 物品获得触发
func trigger_item_acquired(item_id: StringName) -> void:
    upgrade_triggered.emit("item", item_id)

# skill_tree_panel.gd
class_name SkillTreePanel
extends Control
 
@export var skill_unlock_manager: SkillUnlockManager
@export var skill_slot_scene: PackedScene
 
@onready var scroll_container: ScrollContainer = %ScrollContainer
@onready var skill_grid: GridContainer = %SkillGrid
@onready var skill_points_label: Label = %SkillPointsLabel
@onready var skill_info_panel: PanelContainer = %SkillInfoPanel
@onready var skill_name_label: Label = %SkillNameLabel
@onready var skill_desc_label: Label = %SkillDescLabel
@onready var skill_level_label: Label = %SkillLevelLabel
@onready var upgrade_button: Button = %UpgradeButton
 
var skill_slotuis: Array[SkillSlotUI] = []
var selected_skill: SkillData = null
 
func _ready() -> void:
    skill_unlock_manager.skill_unlocked.connect(_on_skill_unlocked)
    skill_unlock_manager.unlock_conditions_changed.connect(_refresh_all)
    
    _create_skill_slots()
    _refresh_all()