Switch Levels with Async and still display progress

Questions & Answers
1

I have a serious issue.

Before you read, please note. I am testing this by using a webplayer build interacting with the editor build and running both at the same time because I need to test a lot of networking code built into this thing. If that is the reason, please let me know.

The problem is that if I enable “LoadLevelAsync” at all, it just freezes and makes both the webplayer and the editor unresponsive. I don’t know why. I also tried posting the async code outside of an enumerator, and still. Nothing.

{
    public UILabel PercentageLabel;

    private Utilities utility;
    private PlayerSettings playerSettings;
    private AsyncOperation theGame;
    private bool CountIncremented = false;

    void Awake()
    {
        utility = GameObject.Find("LoadManager").GetComponent<Utilities>();
        theGrid = GameObject.Find("CharacterGrid");
        gridComponent = theGrid.GetComponent<UIGrid>();
        // Find Playersettings, set the NameLabelText, load the sprite
        playerSettings = GameObject.Find("LoadManager").GetComponent<PlayerSettings>();

        //StartCoroutine("LoadUpLevel");
    }

    void Update()
    {
        PercentageLabel.text = (((int)(theGame.progress * 100f)).ToString() + "%");
        if (theGame.isDone && !CountIncremented)
        {
            networkView.RPC("IncrementCount", RPCMode.Server);
            CountIncremented = true;
        }
        if (utility.ICanLoadTheLevel)
        {
            utility.ICanLoadTheLevel = false;
            CountIncremented = false;
            if (theGame.isDone)
            {
                theGame.allowSceneActivation = true;
            }
        }
    }

    void OnSerializeNetworkView(BitStream stream, NetworkMessageInfo info)
    {
        int asyncprog = 0;
        if (stream.isWriting)
        {
            
            asyncprog = (int)(theGame.progress * 100f);
            stream.Serialize(ref Charname);
            stream.Serialize(ref isServer);
            //stream.Serialize(ref asyncprog);
        }
        else
        {
            stream.Serialize(ref asyncprog);
            //PercentageLabel.text = (asyncprog.ToString() + "%");
        }
    }

    [RPC]
    void IncrementCount()
    {
        //utility.PlayersFinishedLoading++;
        //if (utility.PlayersFinishedLoading >= utility.TotalPlayersInGame)
        //{
        //    utility.StartTheGame();//RPCs utility.ICanLoadTheLevel = true;
        //}
    }

    IEnumerator LoadUpLevel()
    {
        theGame = Application.LoadLevelAsync("MYGAMENAMEHERE");
        theGame.allowSceneActivation = false;

        yield return theGame;
    }
}

Should I not be using an enumerator? Is this impossible, and if so, why?

I realize async is quite complicated, so thank you for your time.

2

I have the answer.

Basically, don’t ever, ever do async operations in Awake.
Ever.

I switched to start, and while it won’t load beyond ~89%, it doesn’t just freeze and die anymore

3

This is the level loader I use for my FPS asset, or well an early version of it. It uses async loading, and first loads a “clear” scene which is empty, which wipes all other objects from the previous scene out, and then loads the next scene.

using System;
using UnityEngine;

[FpsExecutionOrder(-9000)]
public class FpsAppMapLoader : MonoBehaviour {
    FpsGameMap loadMap;
    FpsGameMode loadMode;
    AsyncOperation loadAsync;
    AsyncOperation unloadAsync;

    void Update () {
        if (unloadAsync == null) {
            FpsCallbacks.MapUnloadBegin();
            unloadAsync = Application.LoadLevelAsync("Clear");

        } else if (unloadAsync.isDone == false) {
            FpsCallbacks.MapUnloadProgress(unloadAsync.progress);

        } else {
            if (loadMap == null) {
                UnloadDone();
                Destroy(gameObject);

            } else {      
                if (loadAsync == null) {
                    UnloadDone();

                    FpsCallbacks.MapLoadBegin(loadMap, loadMode); 
                    FpsCallbacks.MapLoadProgress(loadMap, loadMode, 0f); 

                    loadAsync = Application.LoadLevelAsync(loadMap.SceneId);

                } else if (loadAsync.isDone == false) {
                    FpsCallbacks.MapLoadProgress(loadMap, loadMode, loadAsync.progress);

                } else {
                    GC.Collect();

                    FpsCallbacks.MapLoadProgress(loadMap, loadMode, 1f);
                    FpsCallbacks.MapLoadDone(loadMap, loadMode);

                    Destroy(gameObject);
                }
            }
        }
    }

    void UnloadDone () {
        FpsCallbacks.MapUnloadProgress(1f);
        FpsCallbacks.MapUnloadDone();

        GC.Collect();
    }

    void Start () {
        DontDestroyOnLoad(gameObject);
    }

    public static void LoadMap (FpsGameMap map, FpsGameMode mode) {
        var loader = FpsUtils.CreateObject<FpsAppMapLoader>();
        loader.loadMap = map;
        loader.loadMode = mode;

        FpsLog.Game("Loading map '{0}' ({1})", map.Name, mode.Name);
    }
}