跳至主要內容

10. 打磨与发布

EVOCOSMOS2026/4/14大约 9 分钟

10. 伏魔记——打磨与发布

10.1 什么是"打磨"？

想象你做了一桌子菜。菜都熟了，但还需要摆盘、撒葱花、擦桌子、准备碗筷——这些"最后的修饰"就是打磨（Polish）。在游戏开发中，打磨指的是在核心功能完成之后，添加各种"锦上添花"的细节，让游戏体验更加完善。

打磨项目说明生活比喻
多结局系统不同的选择导致不同的结局同一部电影有不同版本
过场动画剧情演出时的动画和对话电影的转场
存档系统多槽位存档/读档游戏的"存档点"
游戏平衡确保难度合适、数值合理调味——不能太咸也不能太淡
导出发布把游戏打包成可执行文件把菜端上桌

10.2 多结局系统

多结局让玩家的选择变得有意义——你帮助了某个NPC，可能就会解锁好的结局；你做了坏事，可能会走向坏结局。

结局判定机制

我们用游戏标记（Flags）来记录玩家在游戏过程中做出的关键选择。游戏结束时，根据这些标记的组合来决定最终结局。

C
using Godot;

/// <summary>
/// 结局类型枚举
/// </summary>
public enum EndingType
{
    Perfect,    // 完美结局——所有任务完成，所有NPC存活
    Good,       // 好结局——主线完成，大部分支线完成
    Normal,     // 普通结局——仅主线完成
    Bad         // 坏结局——关键NPC死亡
}

/// <summary>
/// 结局管理器——根据玩家的选择判定最终结局
/// </summary>
public partial class EndingManager : Node
{
    /// <summary>
    /// 判定结局
    /// </summary>
    public EndingType DetermineEnding()
    {
        var flags = GameManager.Instance;

        // 坏结局：关键NPC死亡
        if (flags.GetFlag("elder_dead"))
            return EndingType.Bad;

        // 完美结局：完成所有主线+支线+救出所有人
        if (flags.GetFlag("saved_all_npcs")
            && flags.GetFlag("found_hidden_treasure")
            && flags.GetFlag("defeated_secret_boss"))
        {
            return EndingType.Perfect;
        }

        // 好结局：主线完成+大部分支线完成
        if (flags.GetFlag("main_quest_complete")
            && flags.GetFlag("side_quests_70_percent"))
        {
            return EndingType.Good;
        }

        // 普通结局：仅主线完成
        if (flags.GetFlag("main_quest_complete"))
            return EndingType.Normal;

        return EndingType.Normal;
    }

    /// <summary>
    /// 显示结局画面
    /// </summary>
    public void ShowEnding(EndingType ending)
    {
        string title = ending switch
        {
            EndingType.Perfect => "完美结局 —— 众生安宁",
            EndingType.Good => "好结局 —— 天下太平",
            EndingType.Normal => "普通结局 —— 归隐山林",
            EndingType.Bad => "坏结局 —— 悲剧收场",
            _ => "结局"
        };

        GD.Print($"结局: {title}");

        // 播放结局动画和字幕...
        // 显示制作人员名单...
    }
}

结局判定逻辑表

条件标记完美结局好结局普通结局坏结局
主线完成需要需要需要不需要
70%支线完成需要需要不需要不需要
救出所有NPC需要不需要不需要不需要
找到隐藏宝物需要不需要不需要不需要
击败隐藏Boss需要不需要不需要不需要
关键NPC死亡不允许不允许不允许触发

10.3 过场动画

过场动画（Cutscene）是在剧情关键节点播放的动画演出。我们用一种简单的方式来实现——序列动画：在指定的时间点，控制角色移动、显示文字、播放音效。

C
using Godot;
using System.Collections.Generic;

/// <summary>
/// 过场动画指令——一条动画指令
/// </summary>
public class CutsceneCommand
{
    public enum CommandType
    {
        MoveCharacter,      // 移动角色到指定位置
        ShowDialogue,        // 显示对话
        Wait,               // 等待指定秒数
        PlayAnimation,      // 播放角色动画
        FadeIn,             // 淡入
        FadeOut,            // 淡出
        PlayMusic,          // 播放音乐
        SetFlag,            // 设置游戏标记
        ScreenShake         // 屏幕震动
    }

    public CommandType Type { get; set; }
    public string TargetId { get; set; }       // 目标角色/NPC的ID
    public Vector2 Position { get; set; }      // 移动目标位置
    public float Duration { get; set; }        // 持续时间
    public string Text { get; set; }           // 对话文字
    public string AnimationName { get; set; }  // 动画名称
}

/// <summary>
/// 过场动画播放器
/// </summary>
public partial class CutscenePlayer : Node
{
    private Queue<CutsceneCommand> _commands = new();
    private bool _isPlaying = false;

    public bool IsPlaying => _isPlaying;

    /// <summary>
    /// 开始播放过场动画
    /// </summary>
    public async void PlayCutscene(List<CutsceneCommand> commands)
    {
        if (_isPlaying) return;

        _isPlaying = true;
        GameManager.Instance.GameState = RpgGameState.Cutscene;

        foreach (var cmd in commands)
        {
            await ExecuteCommand(cmd);
        }

        _isPlaying = false;
        GameManager.Instance.GameState = RpgGameState.TownExplore;
    }

    /// <summary>
    /// 执行一条动画指令
    /// </summary>
    private async Godot.Awaitable ExecuteCommand(CutsceneCommand cmd)
    {
        switch (cmd.Type)
        {
            case CutsceneCommand.CommandType.MoveCharacter:
                await MoveCharacterAsync(cmd.TargetId, cmd.Position, cmd.Duration);
                break;

            case CutsceneCommand.CommandType.ShowDialogue:
                await ShowDialogueAsync(cmd.Text, cmd.Duration);
                break;

            case CutsceneCommand.CommandType.Wait:
                await ToSignal(GetTree().CreateTimer(cmd.Duration), "timeout");
                break;

            case CutsceneCommand.CommandType.FadeIn:
                await FadeAsync(false, cmd.Duration);
                break;

            case CutsceneCommand.CommandType.FadeOut:
                await FadeAsync(true, cmd.Duration);
                break;

            case CutsceneCommand.CommandType.SetFlag:
                GameManager.Instance.SetFlag(cmd.TargetId, true);
                break;
        }
    }

    private async Godot.Awaitable MoveCharacterAsync(
        string charId, Vector2 target, float duration)
    {
        var player = GetTree().CurrentScene?.FindChild(charId) as Node2D;
        if (player == null) return;

        var tween = CreateTween();
        tween.TweenProperty(player, "global_position", target, duration);
        await ToSignal(tween, "finished");
    }

    private async Godot.Awaitable ShowDialogueAsync(string text, float duration)
    {
        var dialogueBox = GetNode<Control>("%DialogueBox");
        var label = dialogueBox.GetNode<Label>("TextLabel");
        label.Text = text;
        dialogueBox.Visible = true;

        await ToSignal(GetTree().CreateTimer(duration), "timeout");
        dialogueBox.Visible = false;
    }

    private async Godot.Awaitable FadeAsync(bool fadeOut, float duration)
    {
        var overlay = GetNode<ColorRect>("%TransitionOverlay");
        var targetAlpha = fadeOut ? 1.0f : 0.0f;

        var tween = CreateTween();
        tween.TweenProperty(overlay, "color:a", targetAlpha, duration);
        await ToSignal(tween, "finished");
    }
}

10.4 存档系统

存档系统让玩家可以保存游戏进度，下次继续玩。

C
using Godot;

/// <summary>
/// 存档管理器——处理游戏进度的保存和加载
/// </summary>
public partial class SaveManager : Node
{
    private const string SaveDir = "user://saves/";

    /// <summary>
    /// 保存游戏到指定槽位
    /// </summary>
    public void SaveGame(int slot)
    {
        // 确保存档目录存在
        if (!DirAccess.DirExistsAbsolute(SaveDir))
        {
            DirAccess.MakeDirRecursiveAbsolute(SaveDir);
        }

        // 收集所有需要保存的数据
        var saveData = new Godot.Collections.Dictionary
        {
            { "slot", slot },
            { "timestamp", System.DateTime.Now.ToString() },
            { "play_time", GameManager.Instance.GetPlayTimeString() },
            { "game_data", GameManager.Instance.GetSaveData() },
            { "map_id", GameManager.Instance.CurrentMap },
            { "player_position", _getPlayerPosition() }
        };

        // 序列化为JSON并写入文件
        string json = Json.Stringify(saveData, "  ");
        string filePath = SaveDir + $"save_{slot}.json";

        var file = FileAccess.Open(filePath, FileAccess.ModeFlags.Write);
        file.StoreString(json);
        file.Close();

        GD.Print($"游戏已保存到槽位 {slot}");
    }

    /// <summary>
    /// 从指定槽位加载游戏
    /// </summary>
    public bool LoadGame(int slot)
    {
        string filePath = SaveDir + $"save_{slot}.json";

        if (!FileAccess.FileExists(filePath))
        {
            GD.PrintErr($"存档文件不存在: 槽位 {slot}");
            return false;
        }

        var file = FileAccess.Open(filePath, FileAccess.ModeFlags.Read);
        string json = file.GetAsText();
        file.Close();

        var jsonParser = new Json()
        {
            Data = new Godot.Collections.Dictionary()
        };
        var parseResult = jsonParser.Parse(json);
        if (parseResult != Error.Ok)
        {
            GD.PrintErr("存档数据解析失败！");
            return false;
        }

        var saveData = (Godot.Collections.Dictionary)jsonParser.Data;

        // 恢复游戏数据
        GD.Print($"从槽位 {slot} 加载游戏");
        return true;
    }

    /// <summary>
    /// 检查指定槽位是否有存档
    /// </summary>
    public bool HasSave(int slot)
    {
        return FileAccess.FileExists(SaveDir + $"save_{slot}.json");
    }

    /// <summary>
    /// 获取存档信息（用于显示在存档界面上）
    /// </summary>
    public Godot.Collections.Dictionary GetSaveInfo(int slot)
    {
        string filePath = SaveDir + $"save_{slot}.json";

        if (!FileAccess.FileExists(filePath))
            return null;

        var file = FileAccess.Open(filePath, FileAccess.ModeFlags.Read);
        string json = file.GetAsText();
        file.Close();

        var jsonParser = new Json();
        jsonParser.Parse(json);
        return (Godot.Collections.Dictionary)jsonParser.Data;
    }

    /// <summary>
    /// 删除指定槽位的存档
    /// </summary>
    public void DeleteSave(int slot)
    {
        string filePath = SaveDir + $"save_{slot}.json";
        if (FileAccess.FileExists(filePath))
        {
            DirAccess.RemoveAbsolute(filePath);
            GD.Print($"已删除槽位 {slot} 的存档");
        }
    }

    private Vector2 _getPlayerPosition()
    {
        var player = GetTree().CurrentScene?.FindChild("Player") as Node2D;
        return player?.GlobalPosition ?? Vector2.Zero;
    }
}

10.5 游戏导出

在Godot中导出游戏的步骤：

  1. 菜单 → 项目 → 导出（Project → Export）
  2. 添加目标平台：
    • Windows Desktop：导出 .exe 可执行文件
    • Linux/X11：导出 Linux 版本
    • macOS：导出 .app 应用
    • Android：导出 APK 安装包
    • Web：导出 HTML5 网页版
  3. 配置导出选项（图标、名称等）
  4. 点击"导出项目"

导出前的检查清单

检查项说明
所有场景能正常加载没有缺失的资源引用
存档功能正常保存→退出→加载→继续
音效文件存在没有找不到的音频文件
输入映射完整所有按键都已配置
窗口大小正确在目标平台上显示正常
游戏能通关从开始到结局的完整流程
没有调试信息移除 GD.Print 或设为仅开发模式

10.6 本章小结

知识点说明
多结局系统根据游戏标记判定完美/好/普通/坏四种结局
过场动画指令队列+异步执行，实现角色移动、对话、淡入淡出
存档系统JSON序列化+文件读写，支持多槽位
导出发布配置导出选项，检查清单，打包为可执行文件

恭喜你！到这里，伏魔记的所有核心系统都已经完成了。从一个空项目到一个完整的RPG，你已经掌握了游戏开发中最重要的技能：把复杂的大问题拆解成一个个小系统，逐个击破。

继续加油，做出属于你自己的游戏吧！

最近更新:
贡献者: zefeng.peng,bobokaka
EVOCOSMOS
Copyright © 2026 EVOCOSMOS