许可优化
许可优化
产品
产品
解决方案
解决方案
服务支持
服务支持
关于
关于
软件库
当前位置:服务支持 >  软件文章 >  Unity开发者转Godot 4从入门到放弃第四篇

Unity开发者转Godot 4从入门到放弃第四篇

阅读数 16
点赞 0
article_banner

UI 系统、资源管理、场景与存档系统完整教程

作者:豆包,昔莘,筱筱

本部分承接前三部分内容,专为熟悉 Unity C# 的资深开发者打造,全程基于Godot 4.x .NET 稳定版,覆盖游戏开发核心的 UI、资源、场景、存档四大基础架构模块,所有内容均与 Unity 开发体系 1:1 精准对标,包含完整可复用的 C# 框架代码、架构差异解析、最佳实践与避坑指南,可直接复制保存为 Markdown 文档。前置要求:已完成前三部分的环境搭建、核心编程体系、2D/3D 核心模块学习,掌握 Godot 节点树、C# 生命周期、信号系统的基础用法。

一、Godot UI 系统全解析(对标 Unity UGUI)

核心前置说明

  • Unity UI 核心是Canvas + 组件式 UGUI:必须以 Canvas 为根节点,所有 UI 元素挂载在 Canvas 下,通过给 GameObject 挂载 RectTransform、Image、Button 等组件实现 UI 功能,布局通过 Layout Group 组件控制。
  • Godot UI 核心是Control 节点体系:所有 UI 元素都是Control类的子类,天生自带 Rect 变换、布局、事件响应能力,无需强制父级 Canvas;布局通过专用容器节点实现,样式通过 Theme 主题统一管理,事件通过信号系统触发,整体架构比 UGUI 更简洁、耦合度更低。
  • 核心思维转换:Unity 是「先建空 GameObject,挂 RectTransform+UI 组件」;Godot 是直接创建对应功能的 Control 子类节点,节点自带所有 UI 能力,通过父子节点关系实现层级与布局,这是 90% Unity 开发者初学时的核心踩坑点。

1. UI 核心概念 1:1 完整映射表

2. 核心布局系统详解(Unity 开发者快速适配)

Godot 的布局系统和 UGUI 底层逻辑一致,都是基于锚点 + 边距的自适应体系,仅参数命名有差异,Unity 开发者可快速平移经验。

2.1 锚点与边距对标

2.2 高频布局预设快速适配

2.3 自动布局容器用法

Godot 的布局容器是专用节点,而非 UGUI 的附加组件,用法更简洁:

  1. 创建容器节点(HBoxContainer/VBoxContainer/GridContainer)
  2. 将需要自动排列的 UI 节点作为容器的直接子节点
  3. 设置容器的Separation(间距)、Alignment(对齐方式)、Custom Minimum Size(最小尺寸)
  4. 子节点通过Size Flags属性控制拉伸规则,对标 UGUI Layout Element 的 Flexible Width/Height Fill:填充父容器可用空间 Expand:抢占额外可用空间,对标 UGUI 的 Flexible 属性 Shrink Center:居中收缩,不拉伸

3. UI 系统 C# 完整实战示例

3.1 主菜单界面实现(对标 UGUI 主菜单)

代码块


using Godot;

[GlobalClass]
public partial class MainMenu : CanvasLayer
{
    // 编辑器中直接拖拽绑定UI节点,对标UGUI的序列化字段
    [Export] public Button StartGameBtn;
    [Export] public Button SettingsBtn;
    [Export] public Button QuitBtn;
    [Export] public Panel SettingsPanel;

    public override void _Ready()
    {
        // 绑定按钮点击信号,对标UGUI的onClick.AddListener
        StartGameBtn.Pressed += OnStartGameClicked;
        SettingsBtn.Pressed += OnSettingsClicked;
        QuitBtn.Pressed += OnQuitClicked;

        // 初始化隐藏设置面板
        SettingsPanel.Visible = false;
    }

    // 开始游戏按钮点击回调
    private void OnStartGameClicked()
    {
        GD.Print("开始游戏");
        // 切换到游戏场景,详见本部分场景管理章节
        GetTree().ChangeSceneToFile("res://Scenes/GameScene.tscn");
    }

    // 设置按钮点击回调
    private void OnSettingsClicked()
    {
        SettingsPanel.Visible = !SettingsPanel.Visible;
    }

    // 退出游戏按钮点击回调
    private void OnQuitClicked()
    {
        GD.Print("退出游戏");
        GetTree().Quit();
    }

    // 节点销毁前解绑信号,防止内存泄漏
    public override void _ExitTree()
    {
        StartGameBtn.Pressed -= OnStartGameClicked;
        SettingsBtn.Pressed -= OnSettingsClicked;
        QuitBtn.Pressed -= OnQuitClicked;
    }
}

     

3.2 角色血条与状态 UI 实现

代码块


using Godot;

[GlobalClass]
public partial class PlayerHUD : CanvasLayer
{
    [Export] public ProgressBar HealthBar;
    [Export] public Label HealthText;
    [Export] public Label ScoreText;
    [Export] public PlayerController Player;

    public override void _Ready()
    {
        // 绑定玩家血量变化信号,实时更新UI
        Player.HealthChanged += OnHealthChanged;
        Player.ScoreChanged += OnScoreChanged;

        // 初始化UI
        OnHealthChanged(Player.CurrentHealth, Player.MaxHealth);
        OnScoreChanged(Player.Score);
    }

    // 血量变化回调,对标UGUI的Slider值更新
    private void OnHealthChanged(int currentHealth, int maxHealth)
    {
        // 设置进度条最大值与当前值
        HealthBar.MaxValue = maxHealth;
        HealthBar.Value = currentHealth;
        // 更新文本
        HealthText.Text = $"{currentHealth}/{maxHealth}";
        // 血量低于20%变红
        HealthBar.Modulate = currentHealth < maxHealth * 0.2f ? Colors.Red : Colors.Green;
    }

    // 分数变化回调
    private void OnScoreChanged(int score)
    {
        ScoreText.Text = $"分数:{score}";
    }

    public override void _ExitTree()
    {
        Player.HealthChanged -= OnHealthChanged;
        Player.ScoreChanged -= OnScoreChanged;
    }
}


     

3.3 背包滚动列表实现(对标 UGUI ScrollRect 循环列表)

代码块


using Godot;
using System.Collections.Generic;

[GlobalClass]
public partial class BackpackUI : Control
{
    [Export] public ScrollContainer ScrollContainer;
    [Export] public GridContainer ItemGrid;
    [Export] public PackedScene ItemCellPrefab; // 背包格子预制体
    [Export] public int ColumnCount = 5; // 列数

    private List<ItemData> _backpackItems = new List<ItemData>();

    public override void _Ready()
    {
        // 设置网格列数
        ItemGrid.Columns = ColumnCount;
        // 模拟初始化背包数据
        InitBackpackData();
        // 刷新背包UI
        RefreshBackpackUI();
    }

    // 初始化背包数据
    private void InitBackpackData()
    {
        for (int i = 0; i < 30; i++)
        {
            _backpackItems.Add(new ItemData
            {
                ItemId = i,
                ItemName = $"道具{i + 1}",
                ItemCount = GD.RandRange(1, 99),
                IconPath = $"res://Textures/Items/item_{i}.png"
            });
        }
    }

    // 刷新背包UI
    public void RefreshBackpackUI()
    {
        // 清空旧格子
        foreach (Node child in ItemGrid.GetChildren())
        {
            child.QueueFree();
        }

        // 生成新格子
        foreach (var item in _backpackItems)
        {
            // 实例化格子预制体
            var itemCell = ItemCellPrefab.Instantiate<ItemCell>();
            // 设置格子数据
            itemCell.SetCellData(item);
            // 绑定点击事件
            itemCell.OnCellClicked += OnItemCellClicked;
            // 加入网格容器
            ItemGrid.AddChild(itemCell);
        }
    }

    // 道具格子点击回调
    private void OnItemCellClicked(ItemData itemData)
    {
        GD.Print($"点击道具:{itemData.ItemName},数量:{itemData.ItemCount}");
        // 处理道具使用逻辑
    }
}

// 道具数据结构体
public struct ItemData
{
    public int ItemId;
    public string ItemName;
    public int ItemCount;
    public string IconPath;
}

// 背包格子脚本
[GlobalClass]
public partial class ItemCell : Button
{
    [Export] public TextureRect ItemIcon;
    [Export] public Label ItemCountText;

    public ItemData CurrentItemData;
    // 定义点击信号
    [Signal] public delegate void OnCellClickedEventHandler(ItemData itemData);

    public void SetCellData(ItemData data)
    {
        CurrentItemData = data;
        // 设置图标
        ItemIcon.Texture = GD.Load<Texture2D>(data.IconPath);
        // 设置数量
        ItemCountText.Text = data.ItemCount.ToString();
        // 绑定点击事件
        Pressed += () => EmitSignal(SignalName.OnCellClicked, CurrentItemData);
    }
}


     

4. UI 系统最佳实践与避坑指南

  1. 【强制规范】UI 层级必须用 CanvasLayer 隔离 主 UI、弹窗、悬浮窗、顶部状态栏必须分属不同的 CanvasLayer,通过Layer属性控制层级(值越大越靠前),避免 UI 层级混乱,对标 UGUI 的多个 Canvas 分 Sorting Layer 管理。
  2. 【高频坑】锚点设置必须先于尺寸调整 和 UGUI 一致,必须先设置锚点预设,再调整节点尺寸和位置,否则父节点尺寸变化时,UI 会出现错位。
  3. 【布局规范】自动布局必须用容器节点 列表、菜单、按钮组等需要自动排列的 UI,必须使用 HBoxContainer/VBoxContainer/GridContainer 容器节点,禁止手动计算位置,避免适配问题,对标 UGUI 禁止手动改 RectTransform 位置的规范。
  4. 【性能优化】禁用不可见 UI 的 Process 回调 弹窗、隐藏面板等不可见的 UI,必须设置ProcessMode = ProcessModeEnum.Disabled,禁用所有生命周期回调,减少 CPU 占用。
  5. 【样式规范】大型项目必须使用 Theme 主题 所有 UI 的字体、颜色、按钮状态、图标必须通过 Theme 主题统一管理,全局复用,避免每个节点单独设置样式,减少冗余资源,方便全局换肤,对标 UGUI 的 Shared Material 与样式预设。
  6. 【事件规范】优先使用信号,禁止硬编码事件判断 UI 交互必须通过信号绑定回调,禁止在_Process中每帧检测鼠标位置与点击状态,避免性能浪费与逻辑混乱。
  7. 【适配规范】使用 Anchor + Container 做全分辨率适配 禁止写死 UI 的绝对像素尺寸,通过锚点拉伸、容器自动布局、Custom Minimum Size控制最小尺寸,配合项目设置中的「拉伸模式」(推荐使用2D拉伸模式),实现全分辨率自适应。

二、Godot 资源管理体系(对标 Unity Resources、Addressables)

核心前置说明

  • Unity 资源管理核心是「Assets 目录 + Resources 加载 + Addressables 可寻址系统 + AssetBundle 分包」,资源路径基于 Assets 目录,加载分为同步 / 异步,支持资源分包、热更新。
  • Godot 资源管理核心是res:// 资源目录 + GD.Load/ResourceLoader 加载 + PCK 分包,资源路径基于项目根目录的 res:// 协议,原生支持引用计数、同步 / 异步加载、资源分包、热更新,整体架构更轻量,无需额外插件即可实现 Addressables 的核心功能。
  • 核心思维转换:Unity 的资源是独立的 Asset,通过 GUID 管理;Godot 的资源是基于文件路径的,所有打包内的资源都通过res://路径访问,持久化资源通过user://路径访问,路径规则更简单,跨平台兼容性更强。

1. 资源管理核心概念 1:1 映射表


2. 资源加载核心用法与 C# 实战

2.1 同步资源加载(对标 Unity Resources.Load)

适用于小体积资源、高频使用的资源,加载时会阻塞主线程,用法和 Unity 完全一致。

代码块


using Godot;

[GlobalClass]
public partial class ResourceTest : Node
{
    // 方式1:编辑器预加载(推荐,零代码,自动预加载,无运行时卡顿)
    [Export] public Texture2D PlayerIcon;
    [Export] public PackedScene PlayerPrefab;
    [Export] public AudioStream JumpSFX;

    public override void _Ready()
    {
        // 方式2:运行时同步加载
        // 加载纹理
        var weaponTexture = GD.Load<Texture2D>("res://Textures/Weapons/sword.png");
        // 加载场景预制体
        var bulletPrefab = GD.Load<PackedScene>("res://Prefabs/Bullet.tscn");
        // 加载音频
        var attackSFX = GD.Load<AudioStream>("res://Audio/SFX/attack.wav");

        // 实例化预制体,对标Unity Instantiate
        var bulletInstance = bulletPrefab.Instantiate<Bullet>();
        AddChild(bulletInstance);
    }

    // 卸载资源
    public void UnloadResource()
    {
        // 卸载单个资源
        ResourceLoader.Unload(PlayerPrefab);
        // 卸载所有未使用的资源
        ResourceLoader.UnloadUnusedResources();
    }
}


     

2.2 异步资源加载(带进度条,对标 Unity Addressables 异步加载)

适用于大体积资源、场景、模型,加载时不阻塞主线程,可显示加载进度,避免游戏卡顿。

代码块


using Godot;
using System.Threading.Tasks;

[GlobalClass]
public partial class AsyncResourceLoader : Node
{
    [Export] public ProgressBar LoadingProgressBar;
    [Export] public Label LoadingTipLabel;

    // 异步加载单个资源
    public async Task<T> LoadResourceAsync<T>(string resourcePath) where T : Resource
    {
        // 发起异步加载请求
        ResourceLoader.LoadThreadedRequest(resourcePath, useSubThreads: true);

        // 监听加载进度
        while (ResourceLoader.LoadThreadedGetStatus(resourcePath) == ResourceLoader.ThreadLoadStatus.InProgress)
        {
            // 获取加载进度(0-1)
            float progress = ResourceLoader.LoadThreadedGetProgress(resourcePath);
            // 更新UI
            LoadingProgressBar.Value = progress * 100;
            LoadingTipLabel.Text = $"资源加载中:{progress * 100:F0}%";
            // 等待下一帧,不阻塞主线程
            await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame);
        }

        // 加载完成,获取资源
        var loadedResource = ResourceLoader.LoadThreadedGet(resourcePath) as T;
        // 加载失败处理
        if (loadedResource == null)
        {
            GD.PushError($"资源加载失败:{resourcePath}");
            return null;
        }

        LoadingTipLabel.Text = "资源加载完成";
        return loadedResource;
    }

    // 批量异步加载资源
    public async Task BatchLoadResourcesAsync(string[] resourcePaths)
    {
        int totalCount = resourcePaths.Length;
        int loadedCount = 0;

        foreach (var path in resourcePaths)
        {
            await LoadResourceAsync<Resource>(path);
            loadedCount++;
            // 更新总进度
            float totalProgress = (float)loadedCount / totalCount;
            LoadingProgressBar.Value = totalProgress * 100;
        }

        GD.Print($"批量加载完成,共加载{totalCount}个资源");
    }
}


     

2.3 资源对象池实现(对标 Unity 对象池,性能优化核心)

适用于高频实例化 / 销毁的对象(子弹、特效、怪物),避免频繁创建销毁节点产生的性能开销与 GC,是游戏性能优化的核心手段。

代码块


using Godot;
using System.Collections.Generic;

[GlobalClass]
public partial class GameObjectPool : Node
{
    // 单例实例,全局访问
    public static GameObjectPool Instance;

    // 对象池字典:key=预制体路径,value=对象队列
    private Dictionary<string, Queue<Node>> _poolDict = new Dictionary<string, Queue<Node>>();
    // 预制体缓存字典
    private Dictionary<string, PackedScene> _prefabCache = new Dictionary<string, PackedScene>();

    public override void _EnterTree()
    {
        // 单例初始化
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            QueueFree();
        }
    }

    // 初始化对象池,预生成指定数量的对象
    public async void InitPool(string prefabPath, int initCount)
    {
        // 加载预制体并缓存
        if (!_prefabCache.ContainsKey(prefabPath))
        {
            var prefab = await LoadResourceAsync<PackedScene>(prefabPath);
            if (prefab == null) return;
            _prefabCache.Add(prefabPath, prefab);
        }

        // 初始化队列
        if (!_poolDict.ContainsKey(prefabPath))
        {
            _poolDict.Add(prefabPath, new Queue<Node>());
        }

        // 预生成对象
        for (int i = 0; i < initCount; i++)
        {
            var instance = _prefabCache[prefabPath].Instantiate();
            instance.ProcessMode = ProcessModeEnum.Disabled;
            instance.Visible = false;
            AddChild(instance);
            _poolDict[prefabPath].Enqueue(instance);
        }

        GD.Print($"对象池初始化完成:{prefabPath},预生成数量:{initCount}");
    }

    // 从对象池获取对象
    public Node SpawnObject(string prefabPath, Node parentNode, Vector2 position = default)
    {
        // 检查预制体是否缓存
        if (!_prefabCache.ContainsKey(prefabPath))
        {
            GD.PushError($"预制体未初始化:{prefabPath}");
            return null;
        }

        Node instance;
        // 池中有空闲对象,直接取出
        if (_poolDict[prefabPath].Count > 0)
        {
            instance = _poolDict[prefabPath].Dequeue();
        }
        // 池为空,新建对象
        else
        {
            instance = _prefabCache[prefabPath].Instantiate();
            AddChild(instance);
        }

        // 初始化对象
        instance.ProcessMode = ProcessModeEnum.Inherit;
        instance.Visible = true;
        // 设置父节点与位置
        instance.Reparent(parentNode);
        if (instance is Node2D node2D)
        {
            node2D.GlobalPosition = position;
        }
        else if (instance is Node3D node3D)
        {
            node3D.GlobalPosition = new Vector3(position.X, position.Y, 0);
        }

        return instance;
    }

    // 将对象回收至对象池
    public void RecycleObject(string prefabPath, Node instance)
    {
        // 检查池是否存在
        if (!_poolDict.ContainsKey(prefabPath))
        {
            instance.QueueFree();
            return;
        }

        // 重置对象状态
        instance.ProcessMode = ProcessModeEnum.Disabled;
        instance.Visible = false;
        instance.Reparent(this);

        // 加入队列
        _poolDict[prefabPath].Enqueue(instance);
    }

    // 清空对象池
    public void ClearPool()
    {
        foreach (var queue in _poolDict.Values)
        {
            while (queue.Count > 0)
            {
                queue.Dequeue().QueueFree();
            }
        }
        _poolDict.Clear();
        _prefabCache.Clear();
    }
}

     

3. 资源管理最佳实践与避坑指南

  1. 【强制规范】高频资源必须预加载 角色、武器、子弹、UI 图标、常用音效等高频使用的资源,必须通过[Export]导出绑定或启动时预加载,禁止运行时频繁调用GD.Load,避免卡顿。
  2. 【性能优化】大体积资源必须异步加载 场景、3D 模型、大贴图、长音频等大体积资源,必须使用ResourceLoader.LoadThreadedRequest异步加载,禁止同步加载阻塞主线程,导致游戏卡顿。
  3. 【高频坑】资源路径区分大小写 Godot 的资源路径在 Windows 下不区分大小写,但在 Linux、Mac、移动端、Web 平台严格区分大小写,必须统一路径命名规范,避免跨平台加载失败。
  4. 【内存优化】及时卸载无用资源 切换场景、关闭大模块后,必须调用ResourceLoader.UnloadUnusedResources()卸载未使用的资源,释放内存,避免内存持续上涨导致游戏崩溃。
  5. 【资源规范】禁止硬编码资源路径 所有资源路径必须用 const 常量定义在统一的配置类中,禁止在代码中硬编码字符串路径,避免拼写错误与后期维护困难。
  6. 【分包规范】大型项目使用 PCK 资源分包 大型项目必须将资源按模块 / 关卡打包为独立的 PCK 文件,运行时动态加载,减少安装包体积,支持资源热更新,对标 Unity 的 AssetBundle 分包。
  7. 【内存泄漏坑】避免循环引用 资源之间避免循环引用,否则引用计数无法归零,资源无法被自动卸载,导致内存泄漏;手动加载的资源,不再使用时必须手动调用ResourceLoader.Unload()卸载。

三、场景管理与关卡切换(对标 Unity SceneManager)

核心前置说明

  • Unity 场景管理核心是SceneManager 类,场景是独立的.unity 文件,加载新场景默认销毁旧场景,支持多场景叠加、异步加载、常驻对象通过 DontDestroyOnLoad 标记。
  • Godot 场景管理核心是SceneTree 场景树,所有场景都是.tscn 文件,本质是一个可实例化的节点,加载场景就是将场景的根节点挂载到全局场景树上,天生支持多场景叠加、嵌套、动态加载卸载,灵活性远超 Unity,无需额外 API 即可实现复杂的场景管理。
  • 核心思维转换:Unity 的场景是「全局独占的」,加载新场景会替换旧场景;Godot 的场景是「节点化的」,所有场景都是一个普通节点,可以同时挂载多个场景到场景树上,自由控制加载、卸载、激活、禁用,这是 Godot 场景管理的核心优势。

1. 场景管理核心概念 1:1 映射表


2. 场景管理 C# 完整框架实现

2.1 场景管理器单例(对标 Unity SceneManager 封装)

代码块


using Godot;
using System.Threading.Tasks;

[GlobalClass]
public partial class SceneManager : Node
{
    // 单例实例,全局访问(需在项目设置中设置为Autoload节点)
    public static SceneManager Instance;

    // 当前激活的场景根节点
    public Node CurrentSceneRoot { get; private set; }
    // 叠加加载的场景字典
    public System.Collections.Generic.Dictionary<string, Node> AdditiveScenes { get; private set; } = new();

    // 加载界面场景路径
    private const string LoadingScenePath = "res://Scenes/LoadingScene.tscn";
    // 全局根节点
    private Node _rootNode => GetTree().Root;

    public override void _EnterTree()
    {
        // 单例初始化
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            QueueFree();
        }
    }

    #region 同步场景切换
    // 同步切换场景,对标Unity SceneManager.LoadScene
    public void ChangeScene(string scenePath)
    {
        // 校验场景路径
        if (!ResourceLoader.Exists(scenePath))
        {
            GD.PushError($"场景不存在:{scenePath}");
            return;
        }

        // 切换场景
        GetTree().ChangeSceneToFile(scenePath);
        // 更新当前场景引用
        CurrentSceneRoot = _rootNode.GetChild(_rootNode.GetChildCount() - 1);
        GD.Print($"场景切换完成:{scenePath}");
    }
    #endregion

    #region 异步场景切换(带加载界面与进度条)
    // 异步切换场景,带加载界面,对标Unity LoadSceneAsync
    public async void ChangeSceneAsync(string targetScenePath)
    {
        // 1. 加载并显示加载界面
        var loadingScene = GD.Load<PackedScene>(LoadingScenePath).Instantiate();
        _rootNode.AddChild(loadingScene);

        // 2. 异步加载目标场景
        var loadTask = LoadSceneAsync(targetScenePath);
        var loadingUI = loadingScene.GetNode<LoadingUI>("LoadingUI");

        // 3. 监听加载进度
        while (!loadTask.IsCompleted)
        {
            loadingUI.SetProgress(loadTask.Result.Progress);
            await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame);
        }

        // 4. 加载完成,获取场景资源
        var targetScene = loadTask.Result.SceneResource;
        if (targetScene == null)
        {
            GD.PushError($"场景加载失败:{targetScenePath}");
            loadingScene.QueueFree();
            return;
        }

        // 5. 销毁旧场景,实例化新场景
        CurrentSceneRoot?.QueueFree();
        CurrentSceneRoot = targetScene.Instantiate();
        _rootNode.AddChild(CurrentSceneRoot);

        // 6. 延迟0.5秒销毁加载界面,给用户看加载完成提示
        await ToSignal(GetTree().CreateTimer(0.5f), SceneTreeTimer.SignalName.Timeout);
        loadingScene.QueueFree();

        GD.Print($"异步场景切换完成:{targetScenePath}");
    }

    // 异步加载场景资源,返回加载进度与资源
    private async Task<(float Progress, PackedScene SceneResource)> LoadSceneAsync(string scenePath)
    {
        // 发起异步加载请求
        ResourceLoader.LoadThreadedRequest(scenePath, useSubThreads: true);

        float progress = 0;
        PackedScene sceneResource = null;

        // 循环检测加载状态
        while (ResourceLoader.LoadThreadedGetStatus(scenePath) == ResourceLoader.ThreadLoadStatus.InProgress)
        {
            progress = ResourceLoader.LoadThreadedGetProgress(scenePath);
            await ToSignal(GetTree(), SceneTree.SignalName.ProcessFrame);
        }

        // 加载完成
        if (ResourceLoader.LoadThreadedGetStatus(scenePath) == ResourceLoader.ThreadLoadStatus.Loaded)
        {
            sceneResource = ResourceLoader.LoadThreadedGet(scenePath) as PackedScene;
            progress = 1f;
        }

        return (progress, sceneResource);
    }
    #endregion

    #region 叠加场景加载/卸载(对标Unity Additive加载)
    // 叠加加载场景,不销毁当前场景
    public async void LoadAdditiveScene(string scenePath)
    {
        // 避免重复加载
        if (AdditiveScenes.ContainsKey(scenePath))
        {
            GD.Print($"场景已加载:{scenePath}");
            return;
        }

        // 异步加载场景
        var sceneResource = await LoadResourceAsync<PackedScene>(scenePath);
        if (sceneResource == null) return;

        // 实例化场景并挂载到根节点
        var sceneRoot = sceneResource.Instantiate();
        _rootNode.AddChild(sceneRoot);
        // 加入字典管理
        AdditiveScenes.Add(scenePath, sceneRoot);

        GD.Print($"叠加场景加载完成:{scenePath}");
    }

    // 卸载叠加加载的场景
    public void UnloadAdditiveScene(string scenePath)
    {
        if (!AdditiveScenes.TryGetValue(scenePath, out var sceneRoot))
        {
            GD.PushError($"场景未加载:{scenePath}");
            return;
        }

        // 销毁场景节点
        sceneRoot.QueueFree();
        // 从字典移除
        AdditiveScenes.Remove(scenePath);

        GD.Print($"叠加场景卸载完成:{scenePath}");
    }
    #endregion
}

// 加载界面UI脚本
[GlobalClass]
public partial class LoadingUI : Control
{
    [Export] public ProgressBar ProgressBar;
    [Export] public Label TipLabel;

    public void SetProgress(float progress)
    {
        ProgressBar.Value = progress * 100;
        TipLabel.Text = $"场景加载中:{progress * 100:F0}%";
    }
}

2.2 常驻节点与 Autoload 配置(对标 Unity DontDestroyOnLoad)

Godot 的 Autoload 自动加载节点是实现全局单例、常驻管理器的最佳方案,切换场景时永远不会被销毁,无需手动调用 DontDestroyOnLoad。

配置步骤:

  1. 打开「项目 → 项目设置 → 自动加载」
  2. 点击「添加」,选择你的管理器场景 / 脚本(如 SceneManager、GameManager、AudioManager)
  3. 设置节点名称,勾选「启用」,点击保存
  4. 项目启动时会自动创建该节点,挂载到场景树的根节点,全局唯一,切换场景不会销毁,可通过类名.Instance全局访问

3. 场景管理最佳实践与避坑指南

  1. 【强制规范】全局管理器必须使用 Autoload 节点 场景管理、音频管理、存档管理、游戏数据等全局单例,必须使用 Autoload 节点实现,禁止用 DontDestroyOnLoad 的方式,避免切换场景时丢失引用、重复创建。
  2. 【高频坑】切换场景前必须解绑跨场景信号 切换场景前,必须解绑当前场景节点与 Autoload 常驻节点之间的信号绑定,否则会导致内存泄漏、空引用异常,对标 Unity 切换场景前解绑静态事件的规范。
  3. 【性能优化】大场景必须异步加载 超过 1000 个节点的大场景,必须使用异步加载 + 加载界面的方式切换场景,禁止同步加载阻塞主线程,导致游戏无响应。
  4. 【场景规范】合理拆分场景,禁止单场景过大 大型项目必须按模块拆分场景:主菜单场景、游戏核心场景、UI 场景、管理场景、关卡场景,通过叠加加载的方式组合使用,避免单场景节点过多导致加载慢、运行卡顿。
  5. 【生命周期坑】场景加载完成后再执行业务逻辑 场景实例化后,不要立即执行业务逻辑,必须等待场景的_Ready()方法执行完成,确保所有节点都已初始化完成,避免获取节点为空的异常。
  6. 【多场景规范】叠加场景必须统一管理 叠加加载的场景必须通过场景管理器统一管理,记录场景路径与根节点引用,禁止直接 AddChild 后不做管理,导致无法卸载、内存泄漏。

四、存档系统完整实现(对标 Unity PlayerPrefs、JSON / 二进制存档)

核心前置说明

  • Unity 存档核心是「PlayerPrefs 键值对存档 + JSON/XML 序列化 + 二进制加密存档」,持久化路径基于 Application.persistentDataPath,需自行处理跨平台路径、加密、数据校验。
  • Godot 存档核心是ConfigFile 键值对存档 + System.Text.Json 序列化 + FileAccess 文件读写,持久化路径基于user://协议,跨平台自动适配,原生支持配置文件、加密、数据校验,无需额外插件即可实现完整的存档功能。
  • 核心思维转换:Unity 的存档需要自行处理路径拼接、文件读写、加密;Godot 的user://路径跨平台通用,ConfigFile原生支持 ini 格式的键值对存档,FileAccess原生支持文件读写与加密,代码量比 Unity 少 60% 以上。

1. 存档系统核心概念 1:1 映射表


2. 存档系统 C# 完整框架实现

2.1 全局设置存档(ConfigFile,对标 Unity PlayerPrefs)

用于存储游戏设置、音量、画质、按键绑定等轻量级键值对数据,用法比 PlayerPrefs 更灵活。

代码块


using Godot;

[GlobalClass]
public partial class SettingsSave : Node
{
    // 单例实例,Autoload节点
    public static SettingsSave Instance;

    // 配置文件实例
    private ConfigFile _configFile = new ConfigFile();
    // 存档文件路径
    private const string SaveFilePath = "user://settings.save";

    // 配置分组与键名常量
    private const string AudioGroup = "Audio";
    private const string GraphicsGroup = "Graphics";
    private const string InputGroup = "Input";

    public override void _EnterTree()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            QueueFree();
        }

        // 启动时加载存档
        LoadSettings();
    }

    #region 加载与保存
    // 加载设置存档
    public void LoadSettings()
    {
        // 检查存档文件是否存在
        if (!FileAccess.FileExists(SaveFilePath))
        {
            GD.Print("设置存档不存在,使用默认设置");
            SetDefaultSettings();
            return;
        }

        // 加载存档文件
        var error = _configFile.Load(SaveFilePath);
        if (error != Error.Ok)
        {
            GD.PushError($"设置存档加载失败,错误码:{error}");
            SetDefaultSettings();
            return;
        }

        GD.Print("设置存档加载完成");
    }

    // 保存设置存档
    public void SaveSettings()
    {
        var error = _configFile.Save(SaveFilePath);
        if (error != Error.Ok)
        {
            GD.PushError($"设置存档保存失败,错误码:{error}");
            return;
        }
        GD.Print("设置存档保存完成");
    }

    // 设置默认设置
    private void SetDefaultSettings()
    {
        SetMasterVolume(1f);
        SetBGMVolume(1f);
        SetSFXVolume(1f);
        SetFullScreen(true);
        SetResolution(1920, 1080);
        SaveSettings();
    }
    #endregion

    #region 音频设置
    public float GetMasterVolume()
    {
        return (float)_configFile.GetValue(AudioGroup, "MasterVolume", 1f);
    }

    public void SetMasterVolume(float value)
    {
        _configFile.SetValue(AudioGroup, "MasterVolume", value);
    }

    public float GetBGMVolume()
    {
        return (float)_configFile.GetValue(AudioGroup, "BGMVolume", 1f);
    }

    public void SetBGMVolume(float value)
    {
        _configFile.SetValue(AudioGroup, "BGMVolume", value);
    }

    public float GetSFXVolume()
    {
        return (float)_configFile.GetValue(AudioGroup, "SFXVolume", 1f);
    }

    public void SetSFXVolume(float value)
    {
        _configFile.SetValue(AudioGroup, "SFXVolume", value);
    }
    #endregion

    #region 画面设置
    public bool GetFullScreen()
    {
        return (bool)_configFile.GetValue(GraphicsGroup, "FullScreen", true);
    }

    public void SetFullScreen(bool isFullScreen)
    {
        _configFile.SetValue(GraphicsGroup, "FullScreen", isFullScreen);
    }

    public Vector2I GetResolution()
    {
        int width = (int)_configFile.GetValue(GraphicsGroup, "ResolutionWidth", 1920);
        int height = (int)_configFile.GetValue(GraphicsGroup, "ResolutionHeight", 1080);
        return new Vector2I(width, height);
    }

    public void SetResolution(int width, int height)
    {
        _configFile.SetValue(GraphicsGroup, "ResolutionWidth", width);
        _configFile.SetValue(GraphicsGroup, "ResolutionHeight", height);
    }
    #endregion
}


     

2.2 游戏存档系统(JSON 结构化存档,支持多存档槽、加密)

用于存储玩家进度、角色数据、关卡进度、背包数据等复杂结构化数据,支持多存档槽、数据校验、自动备份,是商业游戏的标准存档方案。

代码块


using Godot;
using System;
using System.Collections.Generic;
using System.IO;
using System.Security.Cryptography;
using System.Text;
using System.Text.Json;

// 玩家存档数据结构体(可根据游戏需求扩展)
[Serializable]
public class GameSaveData
{
    // 基础信息
    public int SaveSlotId;
    public string SaveTime;
    public int PlayTimeSeconds;
    // 玩家数据
    public int PlayerLevel;
    public int CurrentHealth;
    public int MaxHealth;
    public int Score;
    public Vector2 PlayerPosition;
    // 背包数据
    public List<ItemData> BackpackItems;
    // 关卡进度
    public int UnlockedLevelCount;
    public int CurrentLevelId;
}

[GlobalClass]
public partial class GameSaveManager : Node
{
    // 单例实例,Autoload节点
    public static GameSaveManager Instance;

    // 存档文件加密密钥(自行修改,16位字符)
    private const string EncryptKey = "GodotSave123456";
    // 存档文件路径前缀
    private const string SaveFilePrefix = "user://game_save_";
    // 存档文件后缀
    private const string SaveFileSuffix = ".sav";
    // 最大存档槽数量
    public const int MaxSaveSlotCount = 5;

    // JSON序列化配置
    private readonly JsonSerializerOptions _jsonOptions = new JsonSerializerOptions { WriteIndented = true };

    public override void _EnterTree()
    {
        if (Instance == null)
        {
            Instance = this;
        }
        else
        {
            QueueFree();
        }
    }

    #region 存档核心方法
    // 保存游戏存档到指定槽位
    public bool SaveGame(int slotId, GameSaveData saveData)
    {
        // 校验槽位
        if (slotId < 0 || slotId >= MaxSaveSlotCount)
        {
            GD.PushError($"存档槽位无效:{slotId}");
            return false;
        }

        try
        {
            // 补充存档基础信息
            saveData.SaveSlotId = slotId;
            saveData.SaveTime = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");

            // 1. 序列化为JSON字符串
            string jsonData = JsonSerializer.Serialize(saveData, _jsonOptions);
            // 2. AES加密
            string encryptedData = AesEncrypt(jsonData, EncryptKey);
            // 3. 写入文件
            string filePath = $"{SaveFilePrefix}{slotId}{SaveFileSuffix}";
            using var file = FileAccess.Open(filePath, FileAccess.ModeFlags.Write);
            file.StoreString(encryptedData);

            GD.Print($"存档保存成功,槽位:{slotId},路径:{filePath}");
            return true;
        }
        catch (Exception e)
        {
            GD.PushError($"存档保存失败:{e.Message}");
            return false;
        }
    }

    // 加载指定槽位的游戏存档
    public GameSaveData LoadGame(int slotId)
    {
        // 校验槽位
        if (slotId < 0 || slotId >= MaxSaveSlotCount)
        {
            GD.PushError($"存档槽位无效:{slotId}");
            return null;
        }

        // 检查存档文件是否存在
        string filePath = $"{SaveFilePrefix}{slotId}{SaveFileSuffix}";
        if (!FileAccess.FileExists(filePath))
        {
            GD.Print($"存档槽位{slotId}无存档");
            return null;
        }

        try
        {
            // 1. 读取文件
            using var file = FileAccess.Open(filePath, FileAccess.ModeFlags.Read);
            string encryptedData = file.GetAsText();
            // 2. AES解密
            string jsonData = AesDecrypt(encryptedData, EncryptKey);
            // 3. 反序列化为存档数据
            var saveData = JsonSerializer.Deserialize<GameSaveData>(jsonData, _jsonOptions);

            GD.Print($"存档加载成功,槽位:{slotId}");
            return saveData;
        }
        catch (Exception e)
        {
            GD.PushError($"存档加载失败:{e.Message}");
            return null;
        }
    }

    // 删除指定槽位的存档
    public bool DeleteSave(int slotId)
    {
        string filePath = $"{SaveFilePrefix}{slotId}{SaveFileSuffix}";
        if (!FileAccess.FileExists(filePath))
        {
            GD.Print($"存档槽位{slotId}无存档,无需删除");
            return false;
        }

        DirAccess.RemoveAbsolute(filePath);
        GD.Print($"存档删除成功,槽位:{slotId}");
        return true;
    }

    // 获取所有存档槽位的信息
    public GameSaveData[] GetAllSaveInfos()
    {
        var saveInfos = new GameSaveData[MaxSaveSlotCount];
        for (int i = 0; i < MaxSaveSlotCount; i++)
        {
            saveInfos[i] = LoadGame(i);
        }
        return saveInfos;
    }

    // 创建新的空白存档数据
    public GameSaveData CreateNewSaveData()
    {
        return new GameSaveData
        {
            PlayerLevel = 1,
            CurrentHealth = 100,
            MaxHealth = 100,
            Score = 0,
            PlayerPosition = Vector2.Zero,
            BackpackItems = new List<ItemData>(),
            UnlockedLevelCount = 1,
            CurrentLevelId = 1,
            PlayTimeSeconds = 0
        };
    }
    #endregion

    #region AES加密解密工具方法
    // AES加密
    private string AesEncrypt(string plainText, string key)
    {
        byte[] keyBytes = Encoding.UTF8.GetBytes(key.PadRight(16).Substring(0, 16));
        using Aes aes = Aes.Create();
        aes.Key = keyBytes;
        aes.Mode = CipherMode.CBC;
        aes.IV = keyBytes;

        ICryptoTransform encryptor = aes.CreateEncryptor(aes.Key, aes.IV);
        using MemoryStream ms = new MemoryStream();
        using CryptoStream cs = new CryptoStream(ms, encryptor, CryptoStreamMode.Write);
        using StreamWriter sw = new StreamWriter(cs);
        sw.Write(plainText);
        sw.Close();
        cs.Close();
        return Convert.ToBase64String(ms.ToArray());
    }

    // AES解密
    private string AesDecrypt(string cipherText, string key)
    {
        byte[] keyBytes = Encoding.UTF8.GetBytes(key.PadRight(16).Substring(0, 16));
        byte[] cipherBytes = Convert.FromBase64String(cipherText);

        using Aes aes = Aes.Create();
        aes.Key = keyBytes;
        aes.Mode = CipherMode.CBC;
        aes.IV = keyBytes;

        ICryptoTransform decryptor = aes.CreateDecryptor(aes.Key, aes.IV);
        using MemoryStream ms = new MemoryStream(cipherBytes);
        using CryptoStream cs = new CryptoStream(ms, decryptor, CryptoStreamMode.Read);
        using StreamReader sr = new StreamReader(cs);
        return sr.ReadToEnd();
    }
    #endregion
}

3. 存档系统最佳实践与避坑指南

  1. 【强制规范】存档必须加密 游戏进度、玩家数据等核心存档必须使用 AES 加密,禁止明文存储 JSON/ini 文件,防止玩家修改存档数据破坏游戏平衡。
  2. 【高频坑】必须使用 user:// 路径存储存档 禁止使用 res:// 路径存储存档,res:// 路径在打包后是只读的,只有 user:// 路径在所有平台都有读写权限,跨平台通用。
  3. 【数据安全】必须做存档备份与校验 保存存档时,先写入临时文件,校验无误后再替换原存档文件,避免游戏崩溃时存档损坏;重要存档自动备份,防止存档丢失。
  4. 【性能优化】禁止频繁保存存档 禁止每帧、每秒都保存存档,仅在关键节点(关卡完成、玩家死亡、道具拾取)自动存档,或玩家手动点击保存时执行存档操作,避免磁盘 IO 频繁操作导致卡顿。
  5. 【数据规范】存档数据必须做版本兼容 存档数据结构体必须添加版本号字段,游戏更新后,加载旧版本存档时做数据兼容处理,避免游戏更新后旧存档无法加载。
  6. 【跨平台坑】禁止使用绝对路径 所有存档文件路径必须使用user://协议路径,禁止拼接平台绝对路径,避免 Windows、Mac、移动端路径格式不同导致的存档读写失败。

第五部分预告

第五部分将完整讲解:

  1. Godot 跨平台打包发布全流程(Windows、Mac、Linux、Android、iOS、Web),与 Unity 打包的差异与避坑指南
  2. Godot C# 项目性能优化全方案(CPU、内存、渲染、打包体积优化),对标 Unity Profiler 性能分析
  3. 代码与资源安全加密、反破解方案,C# 代码混淆、资源加密
  4. 跨平台兼容性适配、常见打包报错解决方案
  5. 大型项目工程规范与团队协作方案

免责声明:本文系网络转载或改编,未找到原创作者,版权归原作者所有。如涉及版权,请联系删

相关文章
技术文档
QR Code
微信扫一扫,欢迎咨询~
customer

online

联系我们
武汉格发信息技术有限公司
湖北省武汉市经开区科技园西路6号103孵化器
电话:155-2731-8020 座机:027-59821821
邮件:tanzw@gofarlic.com
Copyright © 2023 Gofarsoft Co.,Ltd. 保留所有权利
遇到许可问题?该如何解决!?
评估许可证实际采购量? 
不清楚软件许可证使用数据? 
收到软件厂商律师函!?  
想要少购买点许可证,节省费用? 
收到软件厂商侵权通告!?  
有正版license,但许可证不够用,需要新购? 
联系方式 board-phone 155-2731-8020
close1
预留信息,一起解决您的问题
* 姓名:
* 手机:

* 公司名称:

姓名不为空

姓名不为空

姓名不为空
手机不正确

手机不正确

手机不正确
公司不为空

公司不为空

公司不为空