godot-product-polisher

name	godot-product-polisher
description	Godot 产品美化与打磨专家，支持自然语言描述自动完成视觉效果增强、音效优化、用户体验改进、成品包装等美化工作

Godot 产品美化专家技能

技能概述

godot-product-polisher 是专门用于 Godot 游戏产品美化与打磨的智能化技能，能够根据用户的自然语言描述自动完成视觉效果增强、音效优化、用户体验改进、成品包装、发布准备等全面的产品美化工作，让游戏从"能用"提升到"精美"。

核心功能

🎨 视觉效果增强

• 光影效果：动态光照、阴影、反射等高级视觉效果
• 粒子特效：精美的粒子特效和环境动画
• 后处理效果：色彩校正、泛光、景深等后处理
• 材质升级：高级PBR材质和着色器效果

🎵 音效系统优化

• 动态音效：情境感知的动态音效系统
• 环境音效：沉浸式的环境音效和氛围音乐
• 音效混合：智能的音频混合和平衡
• 3D音效：空间音频和音效定位

🎮 用户体验改进

• 手感和反馈：操作手感优化和触觉反馈
• 流畅过渡：场景切换和状态变化的无缝过渡
• 引导系统：智能的新手引导和帮助系统
• 无障碍支持：色盲模式、字幕等无障碍功能

📦 成品包装制作

• 图标设计：游戏图标和启动画面设计
• 营销素材：截图、视频、宣传片制作
• 本地化支持：多语言文本和文化适配
• 发布准备：各平台发布包的优化和配置

使用方法

视觉效果升级

用户: "游戏的画面看起来很平淡，需要提升视觉冲击力"
系统: 智能升级：
- 添加动态光影和阴影系统
- 实现屏幕空间反射和泛光效果
- 优化粒子特效和材质表现
- 调整色彩分级和对比度
- 添加环境遮挡和细节纹理

音效体验优化

用户: "游戏的音效很单调，需要更沉浸的音频体验"
系统: 全面优化：
- 创建情境感知的动态音效
- 设计环境音效层次和变化
- 实现智能音频混合系统
- 添加3D空间音效定位
- 优化音效触发和淡入淡出

用户体验打磨

用户: "需要让游戏操作更流畅，用户体验更好"
系统: 精细打磨：
- 优化操作手力和响应时间
- 添加视觉和触觉反馈效果
- 实现流畅的场景过渡动画
- 设计智能的新手引导系统
- 添加无障碍和辅助功能

成品发布准备

用户: "游戏即将发布，需要准备所有发布素材"
系统: 完整准备：
- 设计高质量游戏图标和logo
- 制作营销截图和宣传视频
- 实现多语言本地化支持
- 优化各平台的发布配置
- 准备应用商店描述和关键词

工作流程

1. 产品分析评估

# 分析产品现状
- 评估视觉质量等级
- 识别用户体验痛点
- 确定优化优先级
- 制定美化计划

2. 视觉效果增强

# 提升视觉表现
- 实现高级光照效果
- 添加粒子特效系统
- 优化材质和着色器
- 调整色彩和后期处理

3. 音效系统优化

# 完善音频体验
- 设计动态音效系统
- 创建环境音效层次
- 优化音频混合平衡
- 实现空间音效定位

4. 用户体验改进

# 优化用户体验
- 改进操作手感反馈
- 实现流畅过渡动画
- 添加引导和帮助系统
- 实现无障碍功能

5. 成品包装制作

# 准备发布材料
- 设计图标和视觉素材
- 制作营销宣传内容
- 实现本地化支持
- 优化发布配置

MCP 工具集成

视觉效果工具

• create_shader_material - 创建着色器材质
• configure_lighting - 配置光照系统
• add_particle_effect - 添加粒子特效
• setup_post_processing - 设置后处理效果

音频处理工具

• create_dynamic_audio - 创建动态音效
• mix_audio_tracks - 混合音频轨道
• configure_3d_audio - 配置3D音效
• optimize_audio_compression - 优化音频压缩

用户体验工具

• create_transition_animation - 创建过渡动画
• setup_haptic_feedback - 设置触觉反馈
• implement_accessibility - 实现无障碍功能
• create_tutorial_system - 创建教程系统

发布准备工具

• generate_app_icon - 生成应用图标
• create_screenshot_tool - 创建截图工具
• setup_localization - 设置本地化
• configure_store_listing - 配置商店信息

视觉效果增强系统

智能光照系统

# 智能光照管理器
class_name SmartLightingManager extends Node
@export var enable_dynamic_shadows: bool = true
@export var ambient_light_color: Color = Color(0.3, 0.3, 0.4, 1.0)
@export var time_of_day_system: bool = true

var main_light: DirectionalLight3D
var ambient_light: WorldEnvironment

func _ready() -> void:
    _setup_lighting_system()
    if time_of_day_system:
        _start_time_cycle()

func _setup_lighting_system() -> void:
    # 主光源设置
    main_light = DirectionalLight3D.new()
    add_child(main_light)
    main_light.light_color = Color.WHITE
    main_light.light_energy = 1.0

    if enable_dynamic_shadows:
        main_light.shadow_enabled = true
        main_light.shadow_bias = 0.1

    # 环境光设置
    ambient_light = WorldEnvironment.new()
    add_child(ambient_light)
    var environment = Environment.new()
    ambient_light.environment = environment

    environment.ambient_light_color = ambient_light_color
    environment.ambient_light_sky_contribution = 0.5

func enhance_visual_effects() -> void:
    # 添加屏幕空间反射
    var environment = ambient_light.environment
    environment.ssr_enabled = true
    environment.ssr_max_steps = 64

    # 添加泛光效果
    environment.glow_enabled = true
    environment.glow_intensity = 1.0
    environment.glow_bloom = 0.2

    # 添加景深效果
    environment.dof_blur_far_enabled = true
    environment.dof_blur_far_distance = 50.0
    environment.dof_blur_far_amount = 0.3

func _start_time_cycle() -> void:
    var time_timer = Timer.new()
    time_timer.timeout.connect(_update_time_of_day)
    time_timer.wait_time = 60.0  # 每分钟更新一次
    time_timer.autostart = true
    add_child(time_timer)

func _update_time_of_day() -> void:
    var current_time = Time.get_datetime_dict_from_system()
    var hour = current_time.hour
    var minute = current_time.minute

    # 根据时间调整光照
    var sun_angle = (hour + minute / 60.0) / 24.0 * 2.0 * PI - PI / 2
    main_light.rotation = Vector3(sun_angle, 0, 0)

    # 调整光照颜色和强度
    if hour >= 6 and hour < 12:  # 早晨到中午
        main_light.light_color = Color.YELLOW
        main_light.light_energy = 1.2
    elif hour >= 12 and hour < 18:  # 下午
        main_light.light_color = Color.WHITE
        main_light.light_energy = 1.0
    elif hour >= 18 and hour < 21:  # 傍晚
        main_light.light_color = Color.ORANGE
        main_light.light_energy = 0.8
    else:  # 夜晚
        main_light.light_color = Color.BLUE
        main_light.light_energy = 0.3

高级粒子特效系统

# 高级粒子特效管理器
class_name AdvancedEffectManager extends Node
@export var effect_library: Dictionary = {}

func _ready() -> void:
    _create_effect_library()

func _create_effect_library() -> void:
    # 创建各种预定义特效
    effect_library["magic_explosion"] = create_magic_explosion_effect()
    effect_library["fire_trail"] = create_fire_trail_effect()
    effect_library["ice_shard"] = create_ice_shard_effect()
    effect_library["healing_aura"] = create_healing_aura_effect()

func create_magic_explosion_effect() -> GPUParticles3D:
    var explosion = GPUParticles3D.new()
    explosion.emitting = false
    explosion.one_shot = true

    # 配置爆炸粒子材质
    var material = ParticleProcessMaterial.new()
    material.direction = Vector3.UP
    material.spread = 45.0
    material.initial_velocity_min = 5.0
    material.initial_velocity_max = 15.0
    material.gravity = Vector3.DOWN * 9.8
    material.scale_min = 0.1
    material.scale_max = 0.5

    # 颜色渐变：从白色到紫色到透明
    var color_gradient = Gradient.new()
    color_gradient.add_color_point(0.0, Color.WHITE)
    color_gradient.add_color_point(0.3, Color.MAGENTA)
    color_gradient.add_color_point(0.7, Color.PURPLE)
    color_gradient.add_color_point(1.0, Color.TRANSPARENT)

    material.color = color_gradient
    explosion.process_material = material

    # 配置粒子数量和生命周期
    explosion.amount = 200
    explosion.lifetime = 2.0
    explosion.explosiveness = 0.8

    return explosion

func play_effect(effect_name: String, position: Vector3) -> void:
    var effect_template = effect_library.get(effect_name)
    if not effect_template:
        push_warning("Effect not found: " + effect_name)
        return

    var effect_instance = effect_template.duplicate()
    effect_instance.global_position = position
    get_tree().current_scene.add_child(effect_instance)
    effect_instance.emitting = true

    # 自动清理
    await effect_instance.finished
    effect_instance.queue_free()

func enhance_environment_effects() -> void:
    # 添加环境动态效果
    add_floating_particles()
    add_atmospheric_glow()
    add_dynamic_fog()

func add_floating_particles() -> void:
    var floating_particles = GPUParticles3D.new()
    floating_particles.position = Vector3(0, 10, 0)
    floating_particles.emitting = true

    var material = ParticleProcessMaterial.new()
    material.direction = Vector3.UP
    material.spread = 360.0
    material.initial_velocity_min = 0.5
    material.initial_velocity_max = 2.0
    material.gravity = Vector3.ZERO

    floating_particles.process_material = material
    floating_particles.amount = 50
    floating_particles.lifetime = 10.0

    get_tree().current_scene.add_child(floating_particles)

音效系统优化

动态音效管理器

# 动态音效管理器
class_name DynamicAudioManager extends Node
@export var master_bus_index: int = 0
@export var sfx_bus_index: int = 1
@export var music_bus_index: int = 2

var adaptive_audio_system: AdaptiveAudioSystem
var environmental_audio: EnvironmentalAudioSystem
var audio_mixer: SmartAudioMixer

func _ready() -> void:
    _setup_audio_systems()

func _setup_audio_systems() -> void:
    adaptive_audio_system = AdaptiveAudioSystem.new()
    environmental_audio = EnvironmentalAudioSystem.new()
    audio_mixer = SmartAudioMixer.new()

    add_child(adaptive_audio_system)
    add_child(environmental_audio)
    add_child(audio_mixer)

func enhance_audio_experience() -> void:
    # 实现情境感知音效
    adaptive_audio_system.enable_context_aware_effects()

    # 创建环境音效层次
    environmental_audio.create_atmospheric_layers()

    # 优化音频混合
    audio_mixer.optimize_frequency_spectrum()

# 自适应音频系统
class AdaptiveAudioSystem extends Node
var current_game_state: String = "normal"
var audio_context: Dictionary = {}

func enable_context_aware_effects() -> void:
    # 根据游戏状态调整音效
    set_process(true)

func _process(_delta: float) -> void:
    var game_state = detect_game_state()
    if game_state != current_game_state:
        update_audio_for_state(game_state)
        current_game_state = game_state

func detect_game_state() -> String:
    # 检测当前游戏状态
    var player = get_tree().get_first_node_in_group("player")
    if not player:
        return "normal"

    var health = player.get("health") if player.has_method("get") else 100

    if health < 30:
        return "critical_health"
    elif health < 60:
        return "low_health"
    elif player.get("in_combat", false):
        return "combat"
    else:
        return "normal"

func update_audio_for_state(state: String) -> void:
    match state:
        "critical_health":
            apply_critical_health_audio()
        "low_health":
            apply_low_health_audio()
        "combat":
            apply_combat_audio()
        _:
            apply_normal_audio()

func apply_critical_health_audio() -> void:
    # 添加心跳声
    play_heartbeat_sound()
    # 压低背景音乐
    AudioServer.set_bus_volume_db(AudioServer.get_bus_index("Music"), -10.0)
    # 增强音效
    AudioServer.set_bus_volume_db(AudioServer.get_bus_index("SFX"), 3.0)

3D空间音效系统

# 3D空间音效系统
class_name SpatialAudioSystem extends Node
@export var max_audio_distance: float = 50.0
@export var audio_attenuation_curve: Curve

var audio_listener: AudioListener3D
var spatial_audio_sources: Dictionary = {}

func _ready() -> void:
    _setup_audio_listener()

func _setup_audio_listener() -> void:
    audio_listener = AudioListener3D.new()
    var player = get_tree().get_first_node_in_group("player")
    if player:
        player.add_child(audio_listener)

func play_spatial_sound(sound_path: String, position: Vector3) -> void:
    var audio_player = AudioStreamPlayer3D.new()
    audio_player.stream = load(sound_path)
    audio_player.global_position = position

    # 配置3D音效参数
    audio_player.max_distance = max_audio_distance
    audio_player.unit_size = 1.0
    audio_player.attenuation_model = AudioStreamPlayer3D.ATTENUATION_INVERSE_DISTANCE

    if audio_attenuation_curve:
        audio_player.attenuation_filter_cutoff_hz = audio_attenuation_curve.sample(
            position.distance_to(audio_listener.global_position) / max_audio_distance
        ) * 20000.0

    get_tree().current_scene.add_child(audio_player)
    audio_player.play()

    await audio_player.finished
    audio_player.queue_free()

func create_environmental_reverb(area: Area3D, reverb_preset: AudioEffectReverb.ReverbPreset) -> void:
    var reverb = AudioEffectReverb.new()
    reverb.preset = reverb_preset

    var audio_bus_name = "Reverb_" + str(area.get_instance_id())
    var bus_index = AudioServer.bus_count
    AudioServer.add_bus(bus_index)
    AudioServer.set_bus_name(bus_index, audio_bus_name)
    AudioServer.add_bus_effect(bus_index, reverb)

    # 连接区域检测
    area.body_entered.connect(_on_reverb_area_entered.bind(bus_index))
    area.body_exited.connect(_on_reverb_area_exited.bind(bus_index))

func _on_reverb_area_entered(bus_index: int, body: Node3D) -> void:
    if body.is_in_group("player"):
        var player_audio = body.find_child("AudioPlayer", true, false)
        if player_audio:
            player_audio.bus = AudioServer.get_bus_name(bus_index)

用户体验改进系统

流畅过渡系统

# 流畅过渡管理器
class_name SmoothTransitionManager extends Node
@export var default_transition_duration: float = 0.5
@export var transition_curve: Tween.TransitionType = Tween.TRANS_CUBIC

var active_transitions: Dictionary = {}

func _ready() -> void:
    # 连接场景切换信号
    get_tree().changing_scene.connect(_on_scene_changing)

func transition_scene(new_scene_path: String, transition_type: String = "fade") -> void:
    var transition_node = create_transition(transition_type)
    get_tree().current_scene.add_child(transition_node)

    await transition_node.play_transition()
    get_tree().change_scene_to_file(new_scene_path)
    await transition_node.play_reverse_transition()
    transition_node.queue_free()

func create_transition(type: String) -> Control:
    match type:
        "fade":
            return create_fade_transition()
        "slide":
            return create_slide_transition()
        "circle":
            return create_circle_transition()
        _:
            return create_fade_transition()

func create_fade_transition() -> Control:
    var fade_overlay = ColorRect.new()
    fade_overlay.color = Color.BLACK
    fade_overlay.set_anchors_and_offsets_preset(Control.PRESET_FULL_RECT)
    fade_overlay.mouse_filter = Control.MOUSE_FILTER_IGNORE

    var tween = create_tween()
    fade_overlay.set_script(preload("res://scripts/transitions/fade_transition.gd"))
    fade_overlay.tween = tween

    return fade_overlay

# 淡入淡出过渡脚本
extends Control
@export var tween: Tween
@export var duration: float = 0.5

func play_transition() -> void:
    modulate.a = 0.0
    tween.tween_property(self, "modulate:a", 1.0, duration)\
        .set_trans(Tween.TRANS_CUBIC)\
        .set_ease(Tween.EASE_IN_OUT)
    await tween.finished

func play_reverse_transition() -> void:
    modulate.a = 1.0
    tween.tween_property(self, "modulate:a", 0.0, duration)\
        .set_trans(Tween.TRANS_CUBIC)\
        .set_ease(Tween.EASE_IN_OUT)
    await tween.finished

手感和反馈系统

# 手感和反馈系统
class_name HapticFeedbackSystem extends Node
@export var vibration_duration: float = 0.1
@export var vibration_intensity: float = 0.5

func _ready() -> void:
    if OS.has_feature("mobile"):
        Input.set_use_accumulated_input(false)

func play_feedback(feedback_type: String, intensity: float = 1.0) -> void:
    match feedback_type:
        "button_press":
            play_button_feedback(intensity)
        "impact":
            play_impact_feedback(intensity)
        "success":
            play_success_feedback(intensity)
        "failure":
            play_failure_feedback(intensity)

func play_button_feedback(intensity: float) -> void:
    # 轻微震动表示按钮按下
    if OS.has_feature("mobile"):
        Input.vibrate_handheld(50, intensity * vibration_intensity)

    # 视觉反馈
    var current_focus = get_viewport().gui_get_focus_owner()
    if current_focus and current_focus has Button:
        var button = current_focus as Button
        create_button_press_effect(button)

func create_button_press_effect(button: Button) -> void:
    var original_scale = button.scale
    var tween = create_tween()

    # 按下效果
    tween.tween_property(button, "scale", original_scale * 0.95, 0.05)
    tween.tween_property(button, "scale", original_scale * 1.05, 0.1)
    tween.tween_property(button, "scale", original_scale, 0.05)

func enhance_interaction_feedback() -> void:
    # 为所有交互元素添加反馈
    var buttons = get_tree().get_nodes_in_group("interactable")
    for button in buttons:
        if button is BaseButton:
            button.pressed.connect(_on_interactable_pressed.bind(button))
            button.mouse_entered.connect(_on_interactable_hover.bind(button))

func _on_interactable_pressed(button: BaseButton) -> void:
    play_feedback("button_press")
    create_press_animation(button)

func _on_interactable_hover(button: BaseButton) -> void:
    play_feedback("hover")
    create_hover_effect(button)

成品包装系统

图标和素材生成器

# 图标和素材生成器
class_name IconAndAssetGenerator extends Node
@export var game_name: String = "MyGame"
@export var game_theme_color: Color = Color.BLUE

func generate_app_icons() -> void:
    var icon_sizes = [16, 32, 48, 64, 128, 256, 512, 1024]

    for size in icon_sizes:
        var icon_texture = generate_icon_texture(size)
        save_icon(icon_texture, size)

func generate_icon_texture(size: int) -> ImageTexture:
    var image = Image.create(size, size, false, Image.FORMAT_RGBA8)

    # 创建渐变背景
    for y in range(size):
        for x in range(size):
            var center = Vector2(size / 2.0, size / 2.0)
            var distance = center.distance_to(Vector2(x, y))
            var normalized_distance = distance / (size / 2.0)

            var color = game_theme_color.lerp(Color.BLACK, normalized_distance * 0.7)
            image.set_pixel(x, y, color)

    # 添加游戏名称缩写
    var abbreviation = game_name.substr(0, min(3, game_name.length()))
    # 这里可以使用Godot的绘图API添加文字

    var texture = ImageTexture.new()
    texture.set_image(image)
    return texture

func save_icon(texture: ImageTexture, size: int) -> void:
    var image = texture.get_image()
    var save_path = "res://export/icons/icon_" + str(size) + "x" + str(size) + ".png"
    image.save_png(save_path)

func create_screenshots() -> Array[String]:
    var screenshot_paths: Array[String] = []

    # 定义要截图的场景
    var screenshot_scenes = [
        "res://scenes/main_menu.tscn",
        "res://scenes/gameplay.tscn",
        "res://scenes/settings.tscn"
    ]

    for scene_path in screenshot_scenes:
        var screenshot_path = capture_screenshot(scene_path)
        if screenshot_path:
            screenshot_paths.append(screenshot_path)

    return screenshot_paths

func capture_screenshot(scene_path: String) -> String:
    # 切换到指定场景
    get_tree().change_scene_to_file(scene_path)
    await get_tree().process_frame

    # 等待场景稳定
    await get_tree().create_timer(1.0).timeout

    # 截图
    var screenshot = get_viewport().get_texture().get_image()
    var save_path = "res://export/screenshots/" + scene_path.get_file().get_basename() + ".png"
    screenshot.save_png(save_path)

    return save_path

营销素材制作器

# 营销素材制作器
class_name MarketingAssetGenerator extends Node
@export var game_description: String = ""
@export var feature_list: Array[String] = []

func create_store_listing() -> Dictionary:
    var listing = {
        "title": get_game_title(),
        "description": generate_compelling_description(),
        "features": format_feature_list(),
        "screenshots": get_screenshot_paths(),
        "tags": generate_relevant_tags(),
        "categories": suggest_categories()
    }

    return listing

func generate_compelling_description() -> String:
    var description = game_description

    # 添加吸引人的开头
    if not description.begins_with("Experience") and not description.begins_with("Dive"):
        description = "Experience an unforgettable adventure in " + description

    # 添加特性亮点
    description += "\n\nKey Features:\n"
    for feature in feature_list:
        description += "• " + feature + "\n"

    return description

func create_promotional_video() -> String:
    var video_path = "res://export/videos/promotional_video.mp4"

    # 创建游戏录制脚本
    var recording_script = create_recording_script()
    execute_recording_sequence(recording_script)

    return video_path

func create_recording_script() -> Array[Dictionary]:
    var script = [
        {
            "scene": "res://scenes/main_menu.tscn",
            "duration": 3.0,
            "actions": ["hover_buttons", "click_start"]
        },
        {
            "scene": "res://scenes/gameplay.tscn",
            "duration": 10.0,
            "actions": ["showcase_gameplay", "highlight_features"]
        },
        {
            "scene": "res://scenes/climax_moment.tscn",
            "duration": 5.0,
            "actions": ["dramatic_camera", "slow_motion"]
        }
    ]

    return script

func execute_recording_sequence(script: Array[Dictionary]) -> void:
    # 实现录制序列逻辑
    for sequence in script:
        await record_sequence(sequence)

智能特性

自动质量评估

• 视觉质量评分：自动评估游戏视觉质量
• 音频质量分析：分析音频体验和平衡
• 用户体验指标：计算用户体验指数
• 商业化建议：提供商业化改进建议

智能美化建议

• 色彩优化：智能色彩搭配建议
• 音效增强：音效改进和增强建议
• 交互优化：交互体验优化方案
• 市场定位：目标用户和市场定位建议

个性化定制

• 风格适配：根据游戏类型定制美化风格
• 平台适配：针对不同平台的特色优化
• 用户偏好：根据用户偏好调整美化策略
• 文化适配：考虑不同文化背景的设计

示例实现

完整产品美化系统

# 完整产品美化系统
class_name ComprehensiveProductPolisher extends Node
@export var polish_level: PolishLevel = PolishLevel.HIGH

enum PolishLevel {
    BASIC,
    STANDARD,
    HIGH,
    PREMIUM
}

var lighting_manager: SmartLightingManager
var effect_manager: AdvancedEffectManager
var audio_manager: DynamicAudioManager
var transition_manager: SmoothTransitionManager
var feedback_system: HapticFeedbackSystem
var asset_generator: IconAndAssetGenerator

func _ready() -> void:
    _initialize_polishing_systems()

func _initialize_polishing_systems() -> void:
    # 初始化各个美化系统
    lighting_manager = SmartLightingManager.new()
    effect_manager = AdvancedEffectManager.new()
    audio_manager = DynamicAudioManager.new()
    transition_manager = SmoothTransitionManager.new()
    feedback_system = HapticFeedbackSystem.new()
    asset_generator = IconAndAssetGenerator.new()

    add_child(lighting_manager)
    add_child(effect_manager)
    add_child(audio_manager)
    add_child(transition_manager)
    add_child(feedback_system)
    add_child(asset_generator)

func apply_comprehensive_polish() -> void:
    print("Starting comprehensive product polishing...")

    match polish_level:
        PolishLevel.BASIC:
            await apply_basic_polish()
        PolishLevel.STANDARD:
            await apply_standard_polish()
        PolishLevel.HIGH:
            await apply_high_polish()
        PolishLevel.PREMIUM:
            await apply_premium_polish()

func apply_high_polish() -> void:
    # 视觉效果增强
    lighting_manager.enhance_visual_effects()
    effect_manager.enhance_environment_effects()

    # 音效系统优化
    audio_manager.enhance_audio_experience()

    # 用户体验改进
    transition_manager.enhance_all_transitions()
    feedback_system.enhance_interaction_feedback()

    # 成品包装制作
    asset_generator.generate_app_icons()
    asset_generator.create_screenshots()

func generate_polish_report() -> Dictionary:
    var report = {
        "visual_quality_score": calculate_visual_quality(),
        "audio_quality_score": calculate_audio_quality(),
        "ux_quality_score": calculate_ux_quality(),
        "market_readiness_score": calculate_market_readiness(),
        "improvement_suggestions": get_improvement_suggestions()
    }

    return report

func calculate_visual_quality() -> float:
    # 计算视觉质量评分
    var lighting_score = 0.9 if lighting_manager else 0.5
    var effects_score = 0.85 if effect_manager else 0.4
    var performance_score = calculate_performance_score()

    return (lighting_score + effects_score + performance_score) / 3.0

func get_improvement_suggestions() -> Array[String]:
    var suggestions: Array[String] = []

    var visual_score = calculate_visual_quality()
    if visual_score < 0.8:
        suggestions.append("Consider enhancing lighting effects and particle systems")

    var audio_score = calculate_audio_quality()
    if audio_score < 0.8:
        suggestions.append("Add more dynamic audio effects and environmental sounds")

    var ux_score = calculate_ux_quality()
    if ux_score < 0.8:
        suggestions.append("Improve transition animations and user feedback")

    return suggestions

质量保证

美化效果验证

• 视觉一致性：确保整体视觉风格统一
• 性能影响：确保美化不影响性能
• 用户体验：验证用户体验改善效果
• 平台兼容：确保各平台美化效果一致

商业化准备

• 商店要求：符合各应用商店的要求
• 法律法规：遵守相关法律法规
• 用户反馈：收集和响应用户反馈
• 竞争分析：分析竞争对手产品

持续改进

• 数据收集：收集使用数据和反馈
• 效果评估：定期评估美化效果
• 迭代优化：基于反馈持续优化
• 趋势跟随：跟进行业和设计趋势

使用限制和注意事项

技术限制

• 硬件要求：高级特效可能需要较高硬件配置
• 性能平衡：需要在美化和性能之间找到平衡
• 平台差异：不同平台的渲染能力差异

最佳实践

• 渐进增强：从基础到高级逐步增强
• 用户中心：以用户体验为中心进行美化
• 性能优先：确保美化不影响核心性能

故障排除

常见问题

1. 帧率下降：检查特效和后处理设置
2. 音频问题：验证音频总线配置
3. 界面卡顿：检查过渡动画复杂度
4. 素材生成失败：检查文件路径和权限

调试技巧

• 使用性能监控工具
• 分阶段启用美化效果
• 收集用户使用反馈
• 对比美化前后的表现

更新日志

v1.0.0 (当前版本)

• 基础视觉效果增强
• 音效系统优化
• 用户体验改进
• 成品包装功能

计划功能

• AI驱动美化建议
• 更多平台适配
• 高级特效模板
• 实时美化预览

---

技能状态: ✅ 可用 最后更新: 2025-11-09 兼容性: Godot 4.5+ 依赖: Godot MCP 工具集 + 游戏设计美化知识