10-11-实战-渐进式加载与按需下载

实战-渐进式加载与按需下载

篇章:10-实战篇-从零搭建
状态:已完成
阅读时间:约 25 分钟


一、引言

1.1 本章在系列中的定位

渐进式加载(Progressive Loading)和按需下载(On-Demand Download)是提升玩家体验的关键手段。本章讲解:

  • 渐进式加载的策略
  • 按需下载的实现
  • 预加载与预下载的平衡
  • 资源调度算法

1.2 本章要解决的核心问题

  • 如何让玩家"秒开"游戏?
  • 如何在后台下载未访问的资源?
  • 如何平衡预加载与内存占用?
  • 资源调度算法如何设计?

1.3 阅读前置要求

  • 完成 10-01 到 10-10
  • 了解 C# 异步编程
  • 了解资源调度基础

二、渐进式加载

2.1 渐进式加载的概念

渐进式加载是指将资源加载分多个阶段,每个阶段加载不同优先级的资源。玩家在每个阶段都能看到游戏状态。

[阶段 1] 启动 (0-1s)
    ↓ 加载:启动必需资源
    ↓ 玩家看到:Logo、Loading
    
[阶段 2] 主界面 (1-3s)
    ↓ 加载:主城基础资源
    ↓ 玩家看到:主城框架
    
[阶段 3] 主城完整 (3-5s)
    ↓ 加载:NPC、特效
    ↓ 玩家看到:完整主城
    
[阶段 4] 后台加载 (5s+)
    ↓ 加载:战斗、活动
    ↓ 玩家可以开始游戏

2.2 渐进式加载实现

public class ProgressiveLoader
{
    public async Task ProgressiveLoad()
    {
        // 阶段 1:启动资源(同步)
        ShowSplash();
        await Task.Yield();
        
        // 阶段 2:核心资源(异步)
        ShowLoading("正在加载核心资源...");
        await LoadCriticalResources();
        ShowMainUI();
        
        // 阶段 3:增强资源(异步)
        ShowLoading("正在加载主城...");
        await LoadMainCityResources();
        EnableMainCityInteraction();
        
        // 阶段 4:后台资源(异步,不阻塞)
        _ = Task.Run(LoadBackgroundResources);
    }
    
    async Task LoadCriticalResources()
    {
        var critical = new[] { "logo", "loading", "main_ui" };
        await LoadAllAsync<Sprite>(critical);
    }
    
    async Task LoadMainCityResources()
    {
        var mainCity = new[] { "main_city_scene", "main_ui" };
        await LoadAllAsync<GameObject>(mainCity);
    }
    
    async Task LoadBackgroundResources()
    {
        // 后台静默加载
        var background = new[] { "battle", "shop", "activity" };
        await LoadAllAsync<GameObject>(background);
    }
}

2.3 资源优先级

优先级 资源类型 加载时机
100 启动必需 同步,最先加载
80 当前场景核心 异步,第二批
50 当前场景完整 异步,第三批
30 下一场景 后台预下载
10 远期活动 后台空闲下载
public class PriorityLoader
{
    public Task LoadWithPriority(string location, int priority)
    {
        var op = YooAssets.LoadAssetAsync<Object>(location);
        op.Priority = priority;  // YooAsset 支持优先级
        return op.Task;
    }
}

2.4 玩家感知的优化

public class PlayerPerceptionOptimizer
{
    public void OptimizePerception()
    {
        // 1. 立即显示 Logo
        ShowLogo();
        
        // 2. 加载过程中显示动画
        StartCoroutine(ShowLoadingAnimation());
        
        // 3. 加载完成时淡入主场景
        StartCoroutine(FadeInMainScene());
        
        // 4. 异步加载细节,玩家可立即开始操作
        _ = LoadDetails();
    }
}

三、按需下载

3.1 按需下载的概念

按需下载是指资源在被实际需要时才下载,与"预下载"形成对比。

public class OnDemandLoader
{
    public async Task<T> LoadOnDemand<T>(string location) where T : Object
    {
        // 1. 检查本地缓存
        if (IsCached(location))
        {
            return LoadFromCache<T>(location);
        }
        
        // 2. 检查是否在下载中
        if (IsDownloading(location))
        {
            return await WaitForDownload<T>(location);
        }
        
        // 3. 触发下载
        return await DownloadAndLoad<T>(location);
    }
}

3.2 智能按需下载

public class SmartOnDemand
{
    public async Task<T> SmartLoad<T>(string location) where T : Object
    {
        // 1. 玩家进入新场景
        // 2. 分析当前需要的资源
        // 3. 按优先级下载
        // 4. 关键资源同步加载
        // 5. 非关键资源后台加载
        
        var priority = CalculatePriority(location);
        return await LoadWithPriority<T>(location, priority);
    }
    
    int CalculatePriority(string location)
    {
        // 业务逻辑
        if (location.StartsWith("ui/main/"))
            return 100;
        if (location.StartsWith("character/"))
            return 80;
        if (location.StartsWith("effect/"))
            return 50;
        return 10;
    }
}

3.3 边玩边下载

public class PlayWhileDownload
{
    public async Task EnterSceneWithDownload(string sceneName)
    {
        // 1. 立即加载关键资源(玩家可玩)
        var criticalOps = new[] {
            YooAssets.LoadAssetAsync<GameObject>($"{sceneName}/critical_01"),
            YooAssets.LoadAssetAsync<GameObject>($"{sceneName}/critical_02")
        };
        await Task.WhenAll(criticalOps.Select(op => op.Task));
        
        // 2. 玩家可以开始游戏
        EnterScene(sceneName);
        
        // 3. 后台下载其他资源
        _ = Task.Run(async () =>
        {
            var allOps = criticalOps.Concat(new[] {
                YooAssets.LoadAssetAsync<GameObject>($"{sceneName}/decoration_01"),
                YooAssets.LoadAssetAsync<GameObject>($"{sceneName}/decoration_02")
            });
            await Task.WhenAll(allOps.Select(op => op.Task));
        });
    }
}

四、预加载与预下载

4.1 预加载 vs 预下载

维度 预加载 预下载
时机 启动时 启动时/运行中
目标 资源到内存 资源到磁盘
内存影响 有 无
网络影响 取决于是否需下载 有
玩家体验 即时可用 首次访问快

4.2 预加载实现

public class ResourcePreloader
{
    public async Task Preload(List<string> locations)
    {
        // 并行预加载
        var tasks = locations.Select(loc =>
            YooAssets.LoadAssetAsync<Object>(loc).Task
        );
        await Task.WhenAll(tasks);
        
        // 资源已在内存中
    }
    
    public void PreloadAndKeep(List<string> locations)
    {
        // 预加载并保留
        foreach (var loc in locations)
        {
            var op = YooAssets.LoadAssetAsync<Object>(loc);
            // 不释放
        }
    }
}

4.3 预下载实现

public class ResourcePredownloader
{
    public async Task Predownload(List<string> bundleNames)
    {
        // 1. 静默下载(不阻塞玩家)
        var op = YooAssets.DownloadUpdateAsync();
        
        // 2. 不等待完成
        // 资源到达磁盘后,下次加载时即用
    }
    
    public async Task PredownloadInBackground(List<string> locations)
    {
        // 在后台异步下载
        _ = Task.Run(async () =>
        {
            var op = YooAssets.DownloadUpdateAsync();
            await op.Task;
            Debug.Log("[Predownload] 完成");
        });
    }
}

4.4 智能预下载

public class SmartPredownloader
{
    public async Task SmartPredownload()
    {
        // 根据玩家历史行为预测
        var playerHistory = LoadPlayerHistory();
        
        // 预测可能访问的资源
        var predicted = PredictNextAccess(playerHistory);
        
        // 按预测概率排序
        predicted = predicted.OrderByDescending(p => p.Probability).ToList();
        
        // 只预下载前 50% 的资源
        var toDownload = predicted.Take(predicted.Count / 2).ToList();
        
        // 后台下载
        await PredownloadInBackground(toDownload.Select(p => p.Location).ToList());
    }
}

五、资源调度算法

5.1 调度需求

资源调度器需要平衡:

  • 即时性:玩家当前需要的资源必须立即可用
  • 预知性:玩家即将需要的资源应该预下载
  • 公平性:避免某些资源永远得不到下载
  • 高效性:避免浪费带宽和 CPU

5.2 调度器实现

public class ResourceScheduler
{
    private readonly PriorityQueue<DownloadTask> _queue = new();
    private readonly SemaphoreSlim _concurrency;
    private CancellationTokenSource _cts;
    
    public async Task Start()
    {
        _cts = new CancellationTokenSource();
        await Task.Run(() => ScheduleLoop(_cts.Token));
    }
    
    async Task ScheduleLoop(CancellationToken ct)
    {
        while (!ct.IsCancellationRequested)
        {
            if (_queue.Count == 0)
            {
                await Task.Delay(100, ct);
                continue;
            }
            
            await _concurrency.WaitAsync(ct);
            var task = _queue.Dequeue();
            
            _ = Task.Run(async () =>
            {
                try
                {
                    await ExecuteTask(task);
                }
                finally
                {
                    _concurrency.Release();
                }
            }, ct);
        }
    }
    
    public void Enqueue(DownloadTask task)
    {
        _queue.Enqueue(task, task.Priority);
    }
}

5.3 优先级动态调整

public class DynamicPriority
{
    public int AdjustPriority(DownloadTask task)
    {
        // 1. 基础优先级
        var priority = task.BasePriority;
        
        // 2. 等待时间加成
        var waitTime = DateTime.UtcNow - task.EnqueueTime;
        priority += (int)(waitTime.TotalSeconds / 10);  // 每 10 秒 +1
        
        // 3. 玩家行为加成
        if (IsPlayerMovingToScene(task.Location))
            priority += 50;
        
        return Math.Min(priority, 100);
    }
}

5.4 带宽感知

public class BandwidthAware
{
    public int GetOptimalConcurrency()
    {
        var networkType = Application.internetReachability;
        
        return networkType switch
        {
            NetworkReachability.ReachableViaLocalAreaNetwork => 8,
            NetworkReachability.ReachableViaCarrierDataNetwork => 3,
            NetworkReachability.NotReachable => 0,
            _ => 5
        };
    }
    
    public long GetOptimalBandwidth()
    {
        // 限制带宽(KB/s)
        return Application.internetReachability switch
        {
            NetworkReachability.ReachableViaLocalAreaNetwork => 5 * 1024,  // 5MB/s
            NetworkReachability.ReachableViaCarrierDataNetwork => 500,    // 500KB/s
            _ => 0
        };
    }
}

六、案例:MMO 游戏的渐进式加载

6.1 启动阶段

[T+0s] 玩家点击图标
    ↓
[T+0.5s] 主包加载完成,显示 Logo
    ↓
[T+1s] 初始化 YooAsset
    ↓
[T+1.5s] 检查版本
    ↓
[T+2s] 后台下载 Common 包
    ↓
[T+3s] 显示登录界面
    ↓
[T+3.5s] 玩家输入账号
    ↓
[T+4s] 后台下载 MainCity 包

6.2 玩家进入主城

public class MMOEnterMainCity
{
    public async Task EnterMainCity(string playerId)
    {
        // 1. 立即显示主城框架(已有)
        ShowMainCityFrame();
        
        // 2. 异步加载主城完整资源
        var op = YooAssets.LoadSceneAsync("MainCity");
        await op.Task;
        
        // 3. 玩家可以开始移动
        EnablePlayerMovement();
        
        // 4. 异步加载其他玩家、NPC
        _ = LoadOthers();
        
        // 5. 异步加载战斗资源
        _ = LoadBattle();
    }
}

6.3 战斗场景

public class EnterBattle
{
    public async Task EnterBattle(int dungeonId)
    {
        // 1. 立即加载战斗 UI
        var uiOp = YooAssets.LoadAssetAsync<GameObject>("BattleUI");
        await uiOp.Task;
        
        // 2. 玩家可以点击"开始"
        ShowBattleUI();
        
        // 3. 异步加载战斗场景
        var sceneOp = YooAssets.LoadSceneAsync($"Dungeon_{dungeonId}");
        
        // 4. 显示进度
        ShowLoadingProgress(sceneOp.Progress);
        await sceneOp.Task;
        
        // 5. 加载完成后进入战斗
        EnterDungeon(dungeonId);
    }
}

七、性能监控

7.1 加载时延监控

public class LoadLatencyMonitor
{
    public async Task<T> Monitor<T>(string location) where T : Object
    {
        var sw = Stopwatch.StartNew();
        var op = YooAssets.LoadAssetAsync<T>(location);
        await op.Task;
        sw.Stop();
        
        if (sw.ElapsedMilliseconds > 1000)
        {
            ReportSlowLoad(location, sw.ElapsedMilliseconds);
        }
        
        return op.Status == EOperationStatus.Succeed ? op.Result : null;
    }
}

7.2 玩家等待时间

public class PlayerWaitTimeTracker
{
    public void TrackWaitTime(string sceneName, TimeSpan waitTime)
    {
        ReportMetric($"wait_time.{sceneName}", waitTime.TotalSeconds);
    }
}

八、最佳实践

8.1 加载策略表

资源类型 加载时机 加载方式
启动 UI 启动时 同步
启动资源 启动时 异步
主城资源 进入主城前 异步(必须完成)
战斗资源 进入战斗前 异步(必须完成)
活动资源 启动时/空闲时 异步(后台)
远期 DLC 启动时/空闲时 异步(后台)

8.2 关键原则

  1. 同步用在启动:避免 Loading 闪烁
  2. 异步用在运行时:避免卡顿
  3. 预加载按优先级:避免内存爆炸
  4. 后台下载按带宽:避免网络拥塞
  5. 失败降级必有:避免卡死

8.3 内存预算

平台 推荐内存预算
微信小游戏 < 500MB
Android < 1GB
iOS < 1.5GB
PC < 4GB

九、总结

9.1 本章要点回顾

  • 渐进式加载:分阶段加载,让玩家分阶段看到游戏
  • 按需下载:用到才下载,减少初始下载
  • 预加载/预下载:平衡启动速度和资源占用
  • 资源调度:优先级、动态调整、带宽感知
  • 实战案例:MMO 启动、主城、战斗

9.2 与前后章节的关联

  • 前章:10-10 介绍了小游戏首包规划
  • 本章:聚焦渐进式加载与按需下载
  • 后章:10-12 将介绍后台下载系统

9.3 实践建议

  1. 每个加载都要有优先级
  2. 预加载不能影响启动
  3. 后台下载要带宽感知
  4. 失败降级必有
  5. 监控先于优化

上一篇:小游戏首包资源规划与策略
下一篇:后台下载系统与性能管理

posted @ 2026-11-22 08:57  SmalBox  阅读(5)  评论(0)    收藏  举报